Question Définir une valeur de paramètre par défaut pour une fonction JavaScript


Je voudrais qu'une fonction JavaScript ait des arguments optionnels sur lesquels je mets une valeur par défaut, qui est utilisée si la valeur n'est pas définie. Dans Ruby, vous pouvez le faire comme ceci:

def read_file(file, delete_after = false)
  # code
end

Est-ce que cela fonctionne en JavaScript?

function read_file(file, delete_after = false) {
  // Code
}

2017
2018-05-21 20:07


origine


Réponses:


De ES6 / ES2015, les paramètres par défaut est dans la spécification de langue.

function read_file(file, delete_after = false) {
  // Code
}

fonctionne juste.

Référence: Paramètres par défaut - MDN

Les paramètres de fonction par défaut permettent d'initialiser les paramètres formels avec des valeurs par défaut si aucune valeur ou indéfini est passé.

Vous pouvez aussi simuler le défaut nommé paramètres via la déstructuration:

// the `= {}` below lets you call the function without any parameters
function myFor({ start = 5, end = 1, step = -1 } = {}) { // (A)
    // Use the variables `start`, `end` and `step` here
    ···
}

Pré ES2015,

Il y a beaucoup de façons, mais c'est ma méthode préférée - elle vous permet de transmettre tout ce que vous voulez, y compris faux ou nul. (typeof null == "object")

function foo(a, b) {
  a = typeof a !== 'undefined' ? a : 42;
  b = typeof b !== 'undefined' ? b : 'default_b';
  ...
}

2931
2018-05-21 20:10



function read_file(file, delete_after) {
    delete_after = delete_after || "my default here";
    //rest of code
}

Cela affecte à delete_after la valeur de delete_after si ce n'est pas un Falsey valeur sinon, il affecte la chaîne "my default here". Pour plus de détails, consultez Le sondage de Doug Crockford sur la langue et consultez la section sur les opérateurs.

Cette approche ne fonctionne pas si vous voulez passer dans un Falsey valeur c'est-à-dire false, null, undefined, 0 ou "". Si vous avez besoin Falsey les valeurs à transmettre devraient utiliser la méthode La réponse de Tom Ritter.

Lorsqu'il s'agit d'un certain nombre de paramètres d'une fonction, il est souvent utile de permettre au consommateur de passer les paramètres dans un objet, puis fusionner ces valeurs avec un objet qui contient les valeurs par défaut pour la fonction

function read_file(values) {
    values = merge({ 
        delete_after : "my default here"
    }, values || {});

    // rest of code
}

// simple implementation based on $.extend() from jQuery
function merge() {
    var obj, name, copy,
        target = arguments[0] || {},
        i = 1,
        length = arguments.length;

    for (; i < length; i++) {
        if ((obj = arguments[i]) != null) {
            for (name in obj) {
                copy = obj[name];

                if (target === copy) {
                    continue;
                }
                else if (copy !== undefined) {
                    target[name] = copy;
                }
            }
        }
    }

    return target;
};

utiliser

// will use the default delete_after value
read_file({ file: "my file" }); 

// will override default delete_after value
read_file({ file: "my file", delete_after: "my value" }); 

559
2018-05-21 20:09



Je trouve que quelque chose de simple comme ça est beaucoup plus concis et lisible personnellement.

function pick(arg, def) {
   return (typeof arg == 'undefined' ? def : arg);
}

function myFunc(x) {
  x = pick(x, 'my default');
} 

137
2018-05-21 20:18



Dans ECMAScript 6, vous serez capable d'écrire exactement ce que vous avez:

function read_file(file, delete_after = false) {
  // Code
}

Cela va définir delete_after à false si ce n'est pas présent ou undefined. Vous pouvez utiliser les fonctionnalités ES6 comme celle-ci aujourd'hui avec des transpileurs tels que Babel.

Voir l'article MDN pour plus d'informations.


54
2018-05-29 15:25



Valeurs de paramètre par défaut

Avec ES6, vous pouvez faire peut-être l'un des idiomes les plus courants dans JavaScript concerne la définition d'une valeur par défaut pour un paramètre de fonction. La façon dont nous avons fait cela pendant des années devrait être assez familière:

function foo(x,y) {
 x = x || 11;
 y = y || 31;
 console.log( x + y );
}
foo(); // 42
foo( 5, 6 ); // 11
foo( 5 ); // 36
foo( null, 6 ); // 17

Ce modèle est le plus utilisé, mais il est dangereux quand nous passons des valeurs comme

foo(0, 42)
foo( 0, 42 ); // 53 <-- Oops, not 42

Pourquoi? Parce que le 0 is falsy, et ainsi le x || 11 results in 11, pas directement passé en 0. Pour corriger ce problème, certaines personnes écriront plutôt le chèque de façon plus détaillée comme ceci:

function foo(x,y) {
 x = (x !== undefined) ? x : 11;
 y = (y !== undefined) ? y : 31;
 console.log( x + y );
}
foo( 0, 42 ); // 42
foo( undefined, 6 ); // 17

nous pouvons maintenant examiner une belle syntaxe utile ajoutée à partir de ES6 rationaliser l'affectation des valeurs par défaut aux arguments manquants:

function foo(x = 11, y = 31) {
 console.log( x + y );
}

foo(); // 42
foo( 5, 6 ); // 11
foo( 0, 42 ); // 42
foo( 5 ); // 36
foo( 5, undefined ); // 36 <-- `undefined` is missing
foo( 5, null ); // 5 <-- null coerces to `0`
foo( undefined, 6 ); // 17 <-- `undefined` is missing
foo( null, 6 ); // 6 <-- null coerces to `0`

x = 11 dans une déclaration de fonction est plus comme x !== undefined ? x : 11 que l'idiome beaucoup plus commun x || 11

Expressions de valeur par défaut

Function les valeurs par défaut peuvent être plus que de simples valeurs comme 31; ils peuvent être une expression valide, même un function call:

function bar(val) {
 console.log( "bar called!" );
 return y + val;
}
function foo(x = y + 3, z = bar( x )) {
 console.log( x, z );
}
var y = 5;
foo(); // "bar called"
 // 8 13
foo( 10 ); // "bar called"
 // 10 15
y = 6;
foo( undefined, 10 ); // 9 10

Comme vous pouvez le voir, les expressions de valeur par défaut sont évaluées paresseusement, ce qui signifie qu'elles ne sont exécutées que si et quand elles sont nécessaires, c'est-à-dire quand l'argument d'un paramètre est omis ou non défini.

Une expression de valeur par défaut peut même être un appel d'expression de fonction inline - communément appelée une expression de fonction invoquée immédiatement (IIFE):

function foo( x =
 (function(v){ return v + 11; })( 31 )
) {
 console.log( x );
}
foo(); // 42

18
2017-10-15 17:58



cette solution est de travailler pour moi en js:

function read_file(file, delete_after) {
    delete_after = delete_after || false;
    // Code
}

8
2017-11-16 11:29



Utilisez simplement une comparaison explicite avec undefined.

function read_file(file, delete_after)
{
    if(delete_after === undefined) { delete_after = false; }
}

6
2017-11-16 07:34