Frage Legen Sie einen Standardparameterwert für eine JavaScript-Funktion fest


Ich möchte, dass eine JavaScript-Funktion optionale Argumente hat, für die ich einen Standardwert festlege, der verwendet wird, wenn der Wert nicht definiert ist. In Ruby kannst du es so machen:

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

Funktioniert das in JavaScript?

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

2017
2018-05-21 20:07


Ursprung


Antworten:


Ab ES6 / ES2015 sind die Standardparameter in der Sprachspezifikation.

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

funktioniert einfach.

Referenz: Standardparameter - MDN

Standardfunktionsparameter erlauben die Initialisierung von Formalparametern mit Standardwerten if kein Wert oder nicht definiert ist bestanden.

Du kannst auch simulieren Standard genannt Parameter über 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 - es lässt Sie alles ein, 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';
  ...
}

2931
2018-05-21 20:10



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

Dies weist zu delete_after der Wert von delete_after wenn es nicht ist falsch Wert andernfalls weist er die Zeichenfolge zu "my default here". Für mehr Details, check out Doug Crockfords Überblick über die Sprache und den Abschnitt über Operatoren.

Dieser Ansatz funktioniert nicht, wenn Sie einen übergeben möchten falsch Wert, d.h. false, null, undefined, 0 oder "". Wenn du es brauchst falsch Werte, die an Sie übergeben werden, müssten die Methode in verwenden Tom Ritters Antwort.

Bei einer Reihe von Parametern für eine Funktion ist es oft sinnvoll, dem Verbraucher zu erlauben, die Parameterargumente in einem Objekt und dann zu übergeben verschmelzen 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;
};

benutzen

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



Ich finde etwas Einfaches so, um persönlich viel prägnanter und lesbarer zu sein.

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

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

137
2018-05-21 20:18



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

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

Dies wird eingestellt delete_after zu false wenn es nicht vorhanden ist oder undefined. Sie können ES6 Funktionen wie diese heute mit Transpilern wie Babel.

Weitere Informationen finden Sie im MDN-Artikel.


54
2018-05-29 15:25



Standard-Parameterwerte

Mit ES6 können Sie vielleicht eines der gängigsten Redewendungen in JavaScript bezieht sich auf das Setzen eines Default-Wertes für einen Funktionsparameter. Die Art, wie wir das seit Jahren gemacht haben, sollte ziemlich vertraut aussehen:

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 z

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

Warum? Weil das 0 is falsyund so die x || 11 results in 11, nicht die direkt in 0 übergeben. Um diesen Fehler zu beheben, schreiben einige Leute stattdessen den Scheck ausführlicher wie folgt:

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

Wir können nun eine hilfreiche Syntax untersuchen, die ab dem: ES6 Rationalisierung der Zuweisung von Standardwerten zu fehlenden Argumenten:

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 das viel häufigere Idiom x || 11

Standardwert Ausdrücke

Function Standardwerte können mehr als nur einfache Werte wie 31 sein; Sie können ein beliebiger gültiger 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 können, werden die Standardausdrücke nur langsam ausgewertet, dh sie werden nur dann ausgeführt, wenn sie benötigt werden - das heißt, wenn das Argument eines Parameters nicht angegeben oder nicht definiert ist.

Ein Standardwert-Ausdruck kann sogar ein Inline-Funktionsausdruck-Aufruf sein - üblicherweise als ein direkt aufgerufener Funktionsausdruck bezeichnet (IIFE):

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

18
2017-10-15 17:58



Diese Lösung ist Arbeit für mich in js:

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

8
2017-11-16 11:29



Verwenden Sie einfach einen expliziten Vergleich mit undefined.

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

6
2017-11-16 07:34



Da ich ein langjähriger C ++ - Entwickler bin (Rookie zur Webentwicklung :)), habe ich, als ich zum ersten Mal auf diese Situation stieß, die Parameterzuweisung in der Funktionsdefinition wie folgt in der Frage ausgeführt.

function myfunc(a,b=10)

Aber Vorsicht, es funktioniert nicht in allen Browsern. Für mich hat es auf meinem Desktop chrome funktioniert, aber nicht auf Chrome auf Android funktioniert. Sicherere Option, wie viele oben erwähnt haben, ist -

    function myfunc(a,b)
    {
    if (typeof(b)==='undefined') b = 10;
......
    }

Intention für diese Antwort ist nicht, die gleichen Lösungen zu wiederholen, was andere bereits erwähnt haben, sondern zu informieren, dass die Parameterzuweisung in der Funktionsdefinition in einigen Browsern funktioniert, aber nicht darauf angewiesen ist.


5
2018-05-19 06:40



Als Update ... mit ECMAScript 6 können Sie ENDLICH Setze Standardwerte in Funktionsparameterdeklarationen wie folgt:

function f (x, y = 7, z = 42) {
  return x + y + z
}

f(1) === 50

Wie bezeichnet von - http://es6-features.org/#DefaultParameterValues


4
2017-10-06 16:16