-1
votes

Comment JavaScript est-il effectué sur la composition de la fonction de fonction?

Je suis tombé sur ce modèle dans redx composer fonction. Je ne comprends toujours pas comment dans l'exemple ci-dessous des fonctions sont évalués à partir du dernier et non de la première: xxx

dans le premier Réduire itération L'accumulateur est f2 donc nous obtiendrons f2 (f3 (2)) = 12 . Dans la prochaine itération, nous appellerons f4 (12) = 48 . Dans la dernière itération, nous appellerons F5 (48) = 240 . Donc, l'ordre d'évaluation est F5 (F4 (F2 (F3 (2)))) . Mais en utilisant console.log Je vois que la commande d'évaluation est F2 (F3 (F5 (2)))) qui est également 240 par coïncidence.

Aussi loin que je comprenne la fonction y est appelée tous les éléments de tableau, alors pourquoi seule la dernière fonction obtient 2 comme paramètre? >


                        
                        
                            
                                                                    javascript
                                                                    functional-programming
                                                                    evaluation
                                                            
                        
                                                    
                            
                            
                                1 commentaires
                                
                                                                            mauvaise implémentation de  composer . Plus important encore 1) Ce n'est pas une fonction totale. Utilisez  x => x  (fonction d'identité) comme l'accumulateur initial, le deuxième argument à  Réduire , 2) Prise en charge de plusieurs arguments de la fonction la plus intérieure est stupide et coûteux - vous Besoin de supporter la composition de la fonction unaire, et 3)  TEMP  est inutile, vous ignorez la variable et  renvoyer  immédiatement. Ie  const comp = (f, g) => x => f (g (x)); const compose = (... FS) => fs.reduce (comp, x => x)



                                    
                    3 Réponses :
                    
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     La réduction ne convient pas aux fonctions F2, F3, F3, F5, mais elle crée une fonction de celles-ci. C'est la valeur de l'accumulateur dans chaque itération. Notez que la valeur est une fonction   et non un résultat de l'exécution de la fonction. 

 1: A = F2; B = F3; Valeur de retour (NON TEMP mais fonction Y) = F2 (F3 (... args)) 

 2: A (Valeur de retour précédent) = F2 (F3 (... args)); B = F4; Valeur de retour = F2 (F3 (F4 (... args))) 

 et ainsi de suite ....                                 


                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    2
 votes
                                
                            
                            
                                
                                     Passons à travers le code avec un exemple très simple:  xxx  pré> 
 Aucune valeur initiale n'a été transmise pour réduire, il commencera par la première (F2) et la deuxième valeur (F3) de la matrice et appelez le rappel avec cela,  x  code> est appelé avec  A  code> étant  F2  code> et  B  code> étant  F3  code>. Maintenant,  x  code> ne fait rien, il renvoie juste la fonction  y  code> qui peut accéder à A et B via une fermeture.  p> 
 Réduire continuera maintenant à la troisième élément, le premier argument étant le résultat du rappel précédent (le  Y  code>), et le deuxième argument étant  F4  code>. Maintenant  x  code> est appelé à nouveau, et une autre fermeture est créée sur  y  code>,  y  code> obtient le terme enfin de toute la fonction.  P>  Si nous essayons de visualiser une fonction ainsi fermée, ce sera le suivant:  p>  xxx  pré> 
 désormais désormais appelé  y  code> et transmettez-le. appellera  b  code> ( f4  code>) et transmettez le résultat à l'appel à  A  code> (mercurisé y).  P> 
 a (  b ( ...args))
 f2( f3( f4( 2 ) ) )

                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     La fonction de composition peut être réécrite comme suit:  xxx  pré> 
 après la première itération, la fonction renvoyée qui est transmise en tant qu'accumulateur suivant est le suivant:  P> 
function composedFunction(arg) {
  return f2(f3(f4(f5(arg))));
}

                                

                                                                    
                                    
                                    
                                        0 commentaires