Simplifier les paramètres de repos dans JavaScript

Pour comprendre les paramètres de repos en JavaScript, commençons par créer une fonction pour ajouter deux nombres.

 fonction [19659004] addNumbers  ( num1  num2 )   {
     let  res  =  num1  +  num2 ; 
     return  res ; 
} 

 let  result  =   addNumbers  ( 7 [19659015] 2 ) ; 
console .  log  ( result ) ;  

La fonction ci-dessus prend deux arguments d'entrée et renvoie l'addition des arguments passés. Donc, si vous passez deux nombres, la fonction addNumbers renverra la somme de ces deux nombres.

Cependant, de par leur conception, toutes les fonctions JavaScript sont surchargées ce qui signifie que vous pouvez passer :

• Arguments supplémentaires à la fonction
• Moins d'arguments à la fonction

Dans la définition de la fonction surchargée, vous pouvez ignorer les types, car JavaScript est un langage sans type . Passons moins d'arguments à la fonction addNumbers:

 function   addNumbers  ( num1  num2 )   {
     let  res  =  num1  +  num2 ;  
     return  res ; 
} 
 let  result  =   addNumbers  ( 7 ) ; 
console .  log  ( result ) ;  

Comme vous le voyez, JavaScript ne se plaint pas de moins d'arguments et renvoie NaN comme un résultat. Ensuite, passez plus d'arguments à la fonction addNumbers:

 function   addNumbers  ( num1  num2 )   {[19659007] let  res  =  num1  +  num2 ; 
     return  res ; 
} 
 let  result  =   addNumbers  ( 7   2   4   9   1  ]  6 ) ; 
console .  log  ( result ) ;  

Encore une fois, JavaScript ne se plaint pas d'arguments supplémentaires et attribue les deux premiers arguments à num1 et num2

Maintenant, vous pouvez avoir quelques questions concernant les arguments supplémentaires de la fonction:

• JavaScript ignore-t-il les arguments supplémentaires?
• Existe-t-il un moyen d'accéder à des arguments supplémentaires à l'intérieur de la fonction?

La réponse aux questions ci-dessus est paramètres de repos . JavaScript n'ignore pas les arguments supplémentaires et les représente dans la fonction en utilisant les paramètres de repos .

Les paramètres de repos représentent un nombre inconnu d'arguments sous forme de tableau à l'intérieur de la fonction.
Quelques caractéristiques des autres paramètres sont:

• Il représente les arguments supplémentaires passés dans la fonction.
• Il est toujours défini comme le dernier paramètre formel de la fonction.
• Il est toujours précédé de trois points . Un paramètre de repos avec le nom «foo» est représenté par … foo .

Dans la fonction addNumbers un paramètre de repos peut être ajouté comme indiqué ci-après dans la liste de codes suivante: [19659003] function addNumbers ( num1 num2 … ep ) {
console . log ( ep . length ) ;
let res = num1 + num2 ;
return res ;
}
let result = addNumbers ( 7 2 4 9 1 6 ) ;
console . log ( result ) ;

Maintenant, la fonction addNumbers a un paramètre de repos avec le nom ep . Vous pouvez donner n'importe quel nom au paramètre rest. Comme les paramètres rest représentent des arguments supplémentaires passés à la fonction, vous obtenez 4 en sortie lors de l'impression de sa longueur.

Le paramètre rest est un ** objet tableau **, ce qui signifie que vous pouvez effectuer des opérations telles que push, pop, length, sort, map etc. Vous pouvez effectuer diverses opérations de tableau sur le paramètre rest comme indiqué dans la liste de codes suivante:

 function   addNumbers  ( num1  num2   ...  ep )   {
    console .  log  ( ep .  length ) ; 
    ep .  push  ( 9 ) ; 
    ep  [ 0 ]   =   10 ; 
    console .  log  ( ep .  length ) ; 
    console .  log  ( ep .  sort  () ) ;  
     let  res  =  num1  +  num2 ; 
     return  res ; 
} 
 let  result  =   addNumbers  ( 7   2   4   9   1   6 [19659005]) ; 
console .  log  ( result ) ;  

Une chose importante à garder à l'esprit est que le paramètre rest doit toujours être le dernier paramètre formel du fonction. Le code ci-dessous génère une erreur:

 function   addNumbers  ( num1  ...  ep  num2 )  {
     let  res  =  num1  +  num2 ; 
     return  res ;  
  } [19659169] Pour la fonction ci-dessus, JavaScript devrait générer une erreur indiquant que le paramètre  Rest doit être le dernier paramètre formel.  

 Vous pouvez utiliser le paramètre normal et le paramètre repos ensemble pour répondre à une exigence particulière. Dans l'exemple suivant, la fonction multiplie tous les paramètres supplémentaires par le paramètre formel et renvoie le tableau. 
 function   multiplyNumbers  ( num   ...  ep )   {
     let  res  =  ep .  map  ( e  =>   { 
         return  num  *  e ; 
    } ) ; 

     return  res ; 
} [19659033] let  résultat  =   multiplierNombres  ( 7   2   4   9   1   6 ) ; 
console .  log  ( result ) ;  
 Différence entre les paramètres de repos et l'objet d'arguments
 Outre les paramètres de repos, vous pouvez également utiliser le  arguments object  pour travailler avec des arguments supplémentaires passés à une fonction. Chaque fois que vous appelez une fonction, JavaScript lui transmet l'objet arguments.
 function   addNumbers  ( num1  num2 )  {
    console .  log  ( arguments .  length ) ;  
     let  res  =  num1  +  num2 ; 
     return  res ;  
  } 

 let  res  =   addNumbers  ( 7  5  8  9  2 ) ; 
 Contrairement aux paramètres de repos, le  arguments object  contient tous les arguments passés à la fonction - c'est pourquoi vous obtenez 5 lors de l'impression de la longueur de l'objet arguments. Certaines des différences significatives entre les paramètres de repos et l'objet arguments sont les suivantes:
 Les paramètres de repos représentent le nombre inconnu d'arguments à l'intérieur de la fonction, alors que l'objet arguments représente tous les arguments passés à la fonction.
 Les paramètres de repos sont purs
 Puisque les paramètres de repos sont des instances d'un tableau, des méthodes telles que sort, pop, push, etc. peuvent être appliquées à cela. Cependant, l'application de ces méthodes sur l'objet arguments génère une erreur.
 Donc, pour le code suivant, JavaScript générera une erreur:
 function   addNumbers  ( num1  num2 )  {
    console .  log  ( arguments .  length ) ; 
    arguments .  sort  () ; 
    arguments .  pop  () ; 
     let  res  =  num1  +  num2 ; [19659007] return  res ;  
  } 

 let  res  =   addNumbers  ( 7  5  ,  8  9  2 ) ; 
 In Nested Functions
 Chaque fonction a son propre objet d'arguments   ]donc si vous voulez accéder à l'objet arguments de la fonction parent à l'intérieur d'une fonction enfant, ce n'est pas directement possible. Comme vous le voyez dans le code ci-dessous, la fonction  display  et la fonction  addNumbers  ont toutes deux un objet  arguments .
 function   addNumbers  ( num1  num2 )  {
    
    console .  log  ( arguments .  length ) ; 
    console .  log  ( arguments  [ 0 ] ) ;  

      function   display  ([19659005])  {
         
         console .  log  ( arguments .  length ) ; 
         console .  log  ( arguments  [ 0 ] ) ;      
     } 

      display  ([19659013] 1  9 ) ; 
 } 

 let  res  =   addNumbers  ( 7  ,  5  8  9  2 ) ; 
 Cependant, une fonction enfant peut accéder directement au reste paramètre de la fonction parent, comme indiqué dans le code ci-dessous:
 function   addNumbers  ( num1  num2  ...  ep )  {
    
    console .  log  ( ep .  length ) ;  

      function   display  () [19659005] {
         console .  log  ( ep .  length ) ;  
     } 

      display  ( 1 [19659005] 9 ) ; 
 } 

 let  res  =   addNumbers  ( 7  5  8  9  2 ) ; 
 Ainsi, quand il s'agit de travailler avec des fonctions imbriquées, les paramètres de repos sont une meilleure option qu'un objet arguments.
 Résumé
 En résumé, vous devez connaître les points suivants sur les paramètres de repos:
 Ils représentent les arguments supplémentaires passés dans la fonction à l'intérieur d'un tableau.
 Ils sont toujours défini comme le dernier paramètre formel de la fonction et précédé de trois points.
 Toutes les opérations de tableau telles que push, pop, map, sort, length, etc. peuvent être effectuées sur des paramètres de repos.
 J'espère que vous trouverez cet article utile. Merci d'avoir lu.