6
votes

Intoxication d'asynchronie - Je ne peux pas être la seule personne atteinte

N'oubliez pas que "const intoxing" en C ++, lorsque vous marqueriez une méthode comme const , puis vous avez réalisé que vous avez dû marquer toutes les méthodes appelées const et ensuite toutes les méthodes qu'ils ont appelées, et ainsi de suite?

J'ai un problème avec l'intoxication d'asynchronie, en JavaScript, bien que je ne pense pas que ce soit pertinent, bien qu'il se propage plutôt que de baisser. Lorsqu'une fonction pourrait éventuellement appeler une fonction asynchrone, elle doit elle-même être réécrite comme asynchrone, puis toutes les fonctions qui l'appelent doivent être et ainsi de suite.

Je n'ai pas une question bien formée ici (désolé, mods) mais j'espérais que quelqu'un avait (A) conseil ou (b) une référence qui aurait pu avoir (a).


                        
                        
                            
                                                                    asynchronous
                                                            
                        
                                                    
                            
                            
                                2 commentaires
                                
                                                                            Quelques exemples (avec code) seraient gentils (pour moi).
                                        
                                                                            N'est-ce pas pourquoi les rappels sont pour? Si c'est ce que vous demandez, je ne l'ai pas bien compris.



                                    
                    3 Réponses :
                    
                                            
                            
                                
                                    0
 votes
                                
                            
                            
                                
                                     Si le problème est B () doit bloquer jusqu'à la fin, mais appelle asynchrone A (), alors peut-être un rappel d'un () pourrait définir un drapeau et B () surveille le drapeau. Si A () n'offre pas un rappel, il y a peut-être une valeur quelque part qui change une fois que A () est terminée.                                 

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    2
 votes
                                
                            
                            
                                
                                     Ce n'est pas une mauvaise question. Il y a quelques façons d'avoir à détruire totalement votre flux de contrôle. Remarque: je n'ai pas dit que c'était jolie. 
 Supposons que vous ayez des objets A, B, C et D,  A.Amethod  code> ne renvoie rien et appelle une méthode  getbdata  de b, b appels  getcdata  code> méthode de c, et le problème est c appelement d quelque chose comme si  p>  xxx  pré> 
 et maintenant il a Pour être écrit comme  p>  xxx  pré> 
 Eh bien, vous pouvez toujours ajouter un paramètre de rappel à chacune de vos méthodes, de sorte que, pour le code, le code à ressembler:  p > 
 var A = {  
  ...
    Amethod: function(x,y,z){
        this.B.getBData((1,2,3,function(somethingForA){
            astatement1;
            astatement2;
        });
        ...
     }
  ...
  }    
  //end of A
  ...
 var B = {  
 ...
    Bmethod: function(x,y,z,callback){
        this.C.getCData(1,2,3,function(somethingForB){
          bstatement1;
          var somethingFromB = bstatement2;
           callback(somethingFromB);
        });
        ...
     }
  ...
  }    
  //end of B
  ...
 var C = {  
 ...
    Cmethod: function(x,y,z,callback){
        this.D.getRawData(1,2,3,function(somethingForC) {
           cstatement1;
           var somethingFromC = cstatement2;
           callback(somethingFromC);
        });
     }
  ...
  }    
  //end of C
  ...

                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     La meilleure solution que j'ai vue jusqu'à présent est  Promises . Bien entendu, tout ce qui se produit, c'est que vous échangez une intoxication par l'asynchronisation pour une intoxication pour la promesse (puisqu'un calcul dépendant d'une promesse elle-même doit retourner une promesse, mais les promesses sont beaucoup plus flexibles et puissantes que les rappels.                                 

                                                                    
                                    
                                    
                                        0 commentaires