Paramètres par défaut dans JavaScript | Expliqué avec des exemples
Pour éviter ce résultat indésirable, nous utilisons les paramètres par défaut. Les paramètres par défaut sont les paramètres qui ont défini leurs valeurs par défaut au cas où ils manquent de l'appel de fonction invoquant.
Nous allons examiner un exemple où nous obtenons un résultat non satisfaisant en raison d'arguments manquants, puis nous le réparerons en utilisant des paramètres traditionnels et par défaut. Mais d'abord, apprenons un peu plus sur les paramètres par défaut.
Quels sont les paramètres par défaut
Dans la version ES6, JavaScript a introduit une fonctionnalité de configuration des paramètres par défaut. Lors du développement d'une application complète, nous voulons généralement couvrir toutes nos fins qui peuvent nous renvoyer toute erreur. La question des arguments manquants dans l'appel de fonction invoquant est l'un de ces coins et le paramètre par défaut est le garde que nous utilisons pour nous sauver des résultats indésirables.
Déclarer les paramètres par défaut est plutôt facile. Lors de la définition du paramètre de la fonction, mettez simplement la valeur par défaut après le "=" signe. La syntaxe est comme:
fonction fonction identifiant (paramètre = valeur)// corps de la fonction
;
Par exemple:
functionprintName (FirstName, LastName = 'Doe')console.log (firstName + "+ LastName);
printName ('John');
printname ("John", "Who");
La sortie des deux commandes est:
Pour le premier appel de fonction, il a utilisé la valeur par défaut «Doe» pour le paramètre «LastName» et pour la seconde, il a utilisé les deux arguments.
Comment fonctionnent les paramètres par défaut
En utilisant la même fonction que nous avons créée dans l'exemple ci-dessus, pour le premier cas lorsque les deux arguments sont présents, les valeurs à l'intérieur de l'appel de fonction sont utilisées comme tel:
Et pour le deuxième cas, dans lequel l'un des arguments manquait, la fonction a utilisé la valeur que nous avons définie comme la valeur par défaut dans le paramètre comme:
Pourquoi utiliser les paramètres par défaut
En règle générale, lorsqu'aucun argument n'est passé, le paramètre est considéré comme «non défini» par JavaScript. L'approche traditionnelle ou triviale pour éviter une sortie indésirable est de vérifier le paramètre pour une valeur non définie. L'approche triviale peut être utilisée avec les lignes de code suivantes pour qu'une fonction ajoute 2 nombres:
functionAddNumbers (num1, num2)if (num1 === Undefined)
num1 = 1;
if (num2 === Undefined)
num2 = 1;
return num1 + num2;
console.log (addnumbers ());
Même si nous ne faisons aucun argument lorsque nous appelons la fonction à l'intérieur du console.enregistrer() fonction, nous n'aurons aucune erreur.
En fait, la sortie est comme:
Comme vous pouvez le voir, nous pouvons également gérer la question des arguments manquants comme celui-ci. Cependant, être un bon programmeur, c'est être efficace, et cette approche triviale n'est pas une solution efficace.
Si nous devions résoudre le même problème en utilisant les paramètres par défaut, la solution serait beaucoup plus concise comme:
fonction addnumbers (num1 = 1, num2 = 1)return num1 + num2;
console.log (addnumbers ());
Comme vous pouvez le voir, au lieu d'écrire de nombreuses lignes, nous l'avons fait en une seule ligne et la sortie est exactement la même sans erreur et non Nan.
En utilisant la valeur paramètre par défaut d'un paramètre antérieur
Dans ES6, vous pouvez définir un paramètre par défaut en utilisant le paramètre avant lui. En effet, les paramètres sont initialisés de gauche à droite. Entraînant l'utilisation de paramètres définis antérieurs dans la valeur par défaut des paramètres ultérieurs.
Par exemple, prenez l'extrait suivant:
fonction getome (a, b = a * 2)retourner a * b;
console.log (getome (2));
La fonction getome () prendra 2 paramètres, s'il n'y a qu'un seul argument, il attribuera le deuxième paramètre deux fois la valeur du premier argument.
La sortie est comme:
Depuis, les paramètres sont initialisés de gauche à droite, si nous utilisons un paramètre ultérieur comme valeur par défaut d'un paramètre antérieur, cela entraînera une erreur.
Prenez le code suivant comme exemple:
fonction errorgen (a = b, b = 2)retourner a + b;
console.log (errorgen ());
Ce qui précède respectera une erreur car il essaie d'accéder au paramètre "B" avant même qu'il ne soit initialisé.
La sortie est comme:
Utilisation des fonctions comme valeurs dans les paramètres par défaut
Dans ES6, vous pouvez même utiliser les fonctions comme valeurs de paramètre par défaut. Essayez les lignes de code suivantes:
fonction calc (a, b = getValue (a))retourner a + b;
fonction getValue (num)
retour num * 2;
console.journal (calc (2));
Comme vous pouvez le voir, nous donnons la fonction getValue (num) comme paramètre par défaut pour b Et nous passons le paramètre un à l'intérieur. Le getValue (num) multiples l'argument qui lui a été transmis par 2 et renvoie la valeur. C'est pourquoi, quand nous passons 2 à l'intérieur calc () Fonctionne comme un seul paramètre, nous obtenons ce qui suit:
C'est tout pour les paramètres par défaut dans JavaScript.
Conclusion
Dans ES6, une nouvelle fonctionnalité a été introduite qui était les paramètres par défaut. Pour éviter de rencontrer une erreur en raison des arguments manquants, JavaScript a ajouté cette fonctionnalité. Les paramètres par défaut sont utilisés pour mettre une valeur par défaut d'un argument au moment de la rédaction de cette fonction. Nous avons appris les paramètres par défaut, comment nous pouvons utiliser les paramètres par défaut pour éviter les résultats défavorables, et pourquoi nous devrions utiliser les paramètres par défaut en remplacement de l'approche traditionnelle / triviale ainsi que ses exemples.