Einen Standardparameterwert für eine JavaScript-Funktion festlegen

Question

Ich möchte eine JavaScript-Funktion, um optionale Argumente, die ich einen Standard auf, die verwendet werden, wenn der Wert nicht definiert ist (und ignoriert, wenn der Wert übergeben wird). In Ruby kann man das so machen:

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

Funktioniert das auch in JavaScript?

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

Answer 1

Desde ES6/ES2015 Die Standardparameter sind in der Sprachspezifikation enthalten.

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

funktioniert einfach.

Referenz: Standard-Parameter - MDN

Standardfunktionsparameter ermöglichen die Initialisierung von Formalparametern mit Standardwerten, wenn kein Wert o undefiniert übergeben wird.

Sie können auch Standard simulieren namens Parameter durch Destrukturierung :

// 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
    ···
}

Vor ES2015 ,

Es gibt viele Möglichkeiten, aber dies ist meine bevorzugte Methode - damit können Sie alles eingeben, was Sie wollen, einschließlich false oder null. ( typeof null == "object" )

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

Answer 2

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

Damit wird zugewiesen delete_after den Wert von delete_after wenn es sich nicht um ein falsch Wert, ansonsten wird die Zeichenkette "my default here" . Weitere Einzelheiten finden Sie unter Doug Crockfords Überblick über die Sprache und der Abschnitt über Operatoren .

Dieser Ansatz funktioniert nicht, wenn Sie eine falsch Wert, d.h. false , null , undefined , 0 o "" . Wenn Sie benötigen falsch Werte übergeben werden sollen, müssen Sie die Methode in Die Antwort von Tom Ritter .

Beim Umgang mit einer Reihe von Parametern für eine Funktion ist es oft nützlich, dem Verbraucher zu erlauben, die Parameterargumente in einem Objekt zu übergeben und dann zusammenführen diese Werte mit einem Objekt, das die Standardwerte für die Funktion enthält

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;
};

zu verwenden

// 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" });

Answer 3

Ich persönlich finde so etwas Einfaches viel prägnanter und lesbarer.

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

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

Answer 4

In ECMAScript 6 werden Sie tatsächlich genau das schreiben können, was Sie haben:

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

Damit wird die delete_after a false wenn sie nicht vorhanden ist oder undefined . Sie können ES6-Funktionen wie diese heute mit Transpilern wie Babel .

Weitere Informationen finden Sie in dem MDN-Artikel .

Answer 5

Standard-Parameterwerte

Mit ES6 können Sie eines der vielleicht häufigsten Idiome in JavaScript bezieht sich auf die Festlegung eines Standardwertes für einen Funktionsparameter. Die Art und Weise, wie wir dies seit Jahren tun, sollte uns recht vertraut vorkommen:

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

Dieses Muster wird am häufigsten verwendet, ist aber gefährlich, wenn wir Werte wie

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

Warum? Weil die 0 is falsy und damit die x || 11 results in 11 und nicht die direkt übergebene 0. Um diesen Fehler zu beheben, werden manche Leute die Prüfung ausführlicher schreiben, etwa so:

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

können wir nun eine nette, hilfreiche Syntax untersuchen, die ab dem ES6 um die Zuweisung von Standardwerten für fehlende Argumente zu rationalisieren:

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 in einer Funktionsdeklaration ist eher wie x !== undefined ? x : 11 als die weitaus üblichere Redewendung x || 11

Standardwertausdrücke

Function Standardwerte können mehr als nur einfache Werte wie 31 sein; sie können jeder gültige Ausdruck sein, sogar ein 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

Wie Sie sehen, werden die Standardwertausdrücke nur langsam ausgewertet, d. h. sie werden nur ausgeführt, wenn sie benötigt werden, d. h. wenn das Argument eines Parameters weggelassen wird oder undefiniert ist.

Ein Standardwertausdruck kann sogar ein Inline-Funktionsausdruck sein, der gemeinhin als sofort aufgerufener Funktionsausdruck (Immediately Invoked Function Expression) bezeichnet wird. (IIFE) :

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