JavaScript Paramètres par défaut


Exemple

Avant ECMAScript 2015 (ES6), la valeur par défaut d'un paramètre pouvait être affectée de la manière suivante:

function printMsg(msg) {
  msg = typeof msg !== 'undefined' ? // if a value was provided 
        msg :                        // then, use that value in the reassignemnt
        'Default value for msg.';    // else, assign a default value
  console.log(msg);
}

ES6 a fourni une nouvelle syntaxe où la condition et la réaffectation décrites ci-dessus ne sont plus nécessaires:

6
function printMsg(msg='Default value for msg.') {
    console.log(msg);
}
printMsg(); // -> "Default value for msg."
printMsg(undefined); // -> "Default value for msg."
printMsg('Now my msg in different!'); // -> "Now my msg in different!"

Cela montre également que si un paramètre est manquant lorsque la fonction est appelée, sa valeur reste undefined , comme cela peut être confirmé en le fournissant explicitement dans l'exemple suivant (en utilisant une fonction de flèche ):

6
let param_check = (p = 'str') => console.log(p + ' is of type: ' + typeof p);

param_check(); // -> "str is of type: string"
param_check(undefined); // -> "str is of type: string"

param_check(1); // -> "1 is of type: number"
param_check(this); // -> "[object Window] is of type: object"

Fonctions / variables en tant que valeurs par défaut et paramètres de réutilisation

Les valeurs des paramètres par défaut ne sont pas limitées aux nombres, aux chaînes ou aux objets simples. Une fonction peut également être définie comme valeur par défaut callback = function(){} :

6
function foo(callback = function(){ console.log('default'); }) {
    callback();
}

foo(function (){
    console.log('custom');
});
// custom

foo();
//default

Certaines caractéristiques des opérations peuvent être effectuées via les valeurs par défaut:

  • Un paramètre précédemment déclaré peut être réutilisé comme valeur par défaut pour les valeurs des paramètres à venir.
  • Les opérations en ligne sont autorisées lors de l'attribution d'une valeur par défaut à un paramètre.
  • Les variables existant dans la même portée de la fonction en cours de déclaration peuvent être utilisées dans ses valeurs par défaut.
  • Les fonctions peuvent être appelées afin de fournir leur valeur de retour dans une valeur par défaut.
6
let zero = 0;
function multiply(x) { return x * 2;}

function add(a = 1 + zero, b = a, c = b + a, d = multiply(c)) {
    console.log((a + b + c), d);
}

add(1);                // 4, 4
add(3);                // 12, 12
add(2, 7);             // 18, 18
add(1, 2, 5);          // 8, 10
add(1, 2, 5, 10);      // 8, 20 

Réutiliser la valeur de retour de la fonction dans la valeur par défaut d'un nouvel appel:

6
let array = [1]; // meaningless: this will be overshadowed in the function's scope
function add(value, array = []) {
  array.push(value);
  return array;
}
add(5);         // [5]
add(6);         // [6], not [5, 6]
add(6, add(5)); // [5, 6]

valeur et longueur des arguments en l'absence de paramètres dans l'invocation

L' objet tableau arguments conserve uniquement les paramètres dont les valeurs ne sont pas par défaut, c'est-à-dire celles qui sont explicitement fournies lors de l'appel de la fonction:

6
function foo(a = 1, b = a + 1) {
    console.info(arguments.length, arguments);
    console.log(a,b);
}

foo();        // info: 0 >> []     | log: 1, 2
foo(4);       // info: 1 >> [4]    | log: 4, 5
foo(5, 6);    // info: 2 >> [5, 6] | log: 5, 6