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

Nur um zu zeigen, meine Fähigkeiten zu (lol), oben Funktion kann auch ohne benannte Argumente wie unten geschrieben:

ES5 und höher

function foo() {
    a = typeof arguments[0] !== 'undefined' ? a : 42;
    b = typeof arguments[1] !== 'undefined' ? b : 'default_b';
    ...
}

ES6 und höher

function foo(...rest) {
    a = typeof rest[0] !== 'undefined' ? a : 42;
    b = typeof rest[1] !== 'undefined' ? b : 'default_b';
    ...
}

Answer 2

Ja - Beweis:

function read_file(file, delete_after = false) {
  // Code
  console.log({file,delete_after});
}

// TEST
read_file("A");
read_file("B",true);
read_file("C",false);

Answer 3

Ja, dies wird als Standardparameter bezeichnet

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

Syntax:

function [name]([param1[ = defaultValue1 ][, ..., paramN[ = defaultValueN ]]]) {
   statements
}

Beschreibung:

Parameter von Funktionen sind standardmäßig undefiniert. In manchen Situationen kann es jedoch sinnvoll sein, einen anderen Standardwert festzulegen. In diesem Fall können Standardparameter hilfreich sein.

In der Vergangenheit bestand die allgemeine Strategie zum Festlegen von Standardwerten darin, die Parameterwerte im Hauptteil der Funktion zu testen und einen Wert zuzuweisen, wenn sie undefiniert sind. Wenn im Aufruf kein Wert angegeben wird, ist der Wert undefiniert. Um sicherzustellen, dass der Parameter nicht undefiniert ist, müssen Sie eine bedingte Prüfung durchführen

Mit Standardparametern in ES2015 ist die Prüfung im Funktionskörper nicht mehr notwendig. Jetzt können Sie einfach einen Standardwert in den Funktionskopf setzen.

Ein Beispiel für die Unterschiede:

// OLD METHOD
function multiply(a, b) {
  b = (typeof b !== 'undefined') ?  b : 1;
  return a * b;
}

multiply(5, 2); // 10
multiply(5, 1); // 5
multiply(5);    // 5

// NEW METHOD
function multiply(a, b = 1) {
  return a * b;
}

multiply(5, 2); // 10
multiply(5, 1); // 5
multiply(5);    // 5

Verschiedene Beispiele für die Syntax:

Auffüllen undefiniert gegenüber anderen falschen Werten:

Auch wenn der Wert beim Aufruf explizit festgelegt wird, ist der Wert des Arguments num der Standardwert.

function test(num = 1) {
  console.log(typeof num);
}

test();          // 'number' (num is set to 1)
test(undefined); // 'number' (num is set to 1 too)

// test with other falsy values:
test('');        // 'string' (num is set to '')
test(null);      // 'object' (num is set to null)

Wird zum Zeitpunkt des Aufrufs ausgewertet:

Das Standardargument wird zum Zeitpunkt des Aufrufs ausgewertet, so dass im Gegensatz zu anderen Sprachen bei jedem Funktionsaufruf ein neues Objekt erstellt wird.

function append(value, array = []) {
  array.push(value);
  return array;
}

append(1); //[1]
append(2); //[2], not [1, 2]

// This even applies to functions and variables
function callSomething(thing = something()) {
 return thing;
}

function something() {
  return 'sth';
}

callSomething();  //sth

Standardparameter sind für spätere Standardparameter verfügbar:

Bereits gefundene Parameter sind für spätere Standardparameter verfügbar

function singularAutoPlural(singular, plural = singular + 's',
                        rallyingCry = plural + ' ATTACK!!!') {
  return [singular, plural, rallyingCry];
}

//["Gecko","Geckos", "Geckos ATTACK!!!"]
singularAutoPlural('Gecko');

//["Fox","Foxes", "Foxes ATTACK!!!"]
singularAutoPlural('Fox', 'Foxes');

//["Deer", "Deer", "Deer ... change."]
singularAutoPlural('Deer', 'Deer', 'Deer peaceably and respectfully \ petition the government for positive change.')

Funktionen, die innerhalb des Funktionskörpers definiert sind:

Eingeführt in Gecko 33 (Firefox 33 / Thunderbird 33 / SeaMonkey 2.30). Funktionen, die im Funktionskörper deklariert sind, können nicht innerhalb von Standardparametern referenziert werden und werfen einen ReferenceError (derzeit ein TypeError in SpiderMonkey, siehe Bug 1022967). Standardparameter werden immer zuerst ausgeführt, Funktionsdeklarationen innerhalb des Funktionskörpers werden danach ausgewertet.

// Doesn't work! Throws ReferenceError.
function f(a = go()) {
  function go() { return ':P'; }
}

Parameter ohne Standardwerte nach den Standardparametern:

Vor Gecko 26 (Firefox 26 / Thunderbird 26 / SeaMonkey 2.23 / Firefox OS 1.2) führte der folgende Code zu einem SyntaxError. Dies wurde in Bug 777060 behoben und funktioniert in späteren Versionen wie erwartet. Parameter werden immer noch von links nach rechts gesetzt und überschreiben die Standardparameter, auch wenn es später Parameter ohne Standardwerte gibt.

function f(x = 1, y) {
  return [x, y];
}

f(); // [1, undefined]
f(2); // [2, undefined]

Destrukturierter Parameter mit Standardwertzuweisung:

Sie können die Standardwertzuweisung mit der Notation der destruktiven Zuweisung verwenden

function f([x, y] = [1, 2], {z: z} = {z: 3}) {
  return x + y + z;
}

f(); // 6

Answer 4

Ich habe bemerkt, ein paar Antworten zu erwähnen, dass mit Standard-Params ist nicht portabel zu anderen Browsern, aber es ist nur fair, darauf hinzuweisen, dass Sie Transpiler wie Babel verwenden können, um Ihren Code in ES5-Syntax für Browser, die begrenzte Unterstützung für moderne JS-Funktionen haben konvertieren.

Also dies:

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

würde wie folgt umgesetzt werden (probieren Sie es in der Babel REPL aus ->) https://babeljs.io/repl/ ):

"use strict";

function read_file(file) {

  var delete_after =
    arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

  //Code...

}

Wenn Sie nicht die Absicht haben, die Transpilierung zu verwenden, können Sie natürlich auch die Standardparameter im Hauptteil der Funktion festlegen, wie es andere bereits getan haben.

Answer 5

Ein anderer Ansatz zur Festlegung von Standardparametern ist die Verwendung einer Objekt-Map von Argumenten anstelle von direkten Argumenten. Zum Beispiel,

const defaultConfig = {
 category: 'Animals',
 legs: 4
};

function checkOrganism(props) {
 const category = props.category || defaultConfig.category;
 const legs = props.legs || defaultConfig.legs;
}

Auf diese Weise ist es einfach, die Argumente zu erweitern und sich keine Sorgen über eine falsche Argumentlänge zu machen.