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

2367

Ich möchte, dass eine JavaScript-Funktion optionale Argumente hat, für die ich einen Standardwert festgelegt habe. Diese werden verwendet, wenn der Wert nicht definiert ist (und ignoriert, wenn der Wert übergeben wird). In Ruby können Sie dies folgendermaßen tun:

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

Funktioniert das in JavaScript?

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

Antworten:

3297

Ab ES6 / ES2015 befinden sich die Standardparameter in der Sprachspezifikation.

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

funktioniert einfach.

Referenz: Standardparameter - MDN

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

Sie können auch benannte Standardparameter über die Destrukturierung simulieren :

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

Pre ES2015 ,

Es gibt viele Möglichkeiten, aber dies ist meine bevorzugte Methode - Sie können damit alles übergeben, 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';
  ...
}
Tom Ritter
quelle
216
Sie können es auch als solches kapseln: function defaultFor(arg, val) { return typeof arg !== 'undefined' ? arg : val; }und dann können Sie es alsa = defaultFor(a, 42);
Camilo Martin
6
@SiPlus und Sie haben beim Versuch, undefinedObjekte zu verwenden, kostenlos zusätzliche Referenzfehler erhalten : p Auch wenn es mit einigen Browsern funktioniert und möglicherweise schneller ist, nullist es immer noch ein Objekt und undefinedverweist auf den primitiven Typ, der versucht, dies zu erkennen nichts hier, nicht einmal null. Siehe hier, beide Fälle auf den Punkt gebracht: JavaScript / Reference / Global_Objects / undefined .
Sampo Sarrala - codidact.org
9
Wenn Sie die Eigenschaft eines Objekts überprüfen, typeofist dies redundant. function foo(data) { var bar = data.bar !== undefined ? data.bar : 'default'; }Dies wirft keine Referenzfehler und ist prägnant.
Dziamid
10
Ich weiß, dass es wirklich geringfügig ist, aber ich mag nicht, wie Sie zuweisen a = aund b = bwann diese Parameter nicht undefiniert sind. Außerdem kann dieser ternäre Operator mit einem etwas komplizierten Zustand für zukünftige Betreuer schwer zu lesen sein. Ich würde die folgende Syntax bevorzugen: if (typeof a == 'undefined') a = 42- Keine unnötige Zuordnung und etwas leichter zu lesen.
Daddy32
12
Gibt es einen Grund zur Verwendung typeof? Es scheint einfacher zu sein, es einfach zu tun a === undefined. Auf diese Weise erhalten Sie einen Referenzfehler, wenn Sie falsch geschrieben oder undefinedin eine Zeichenfolge eingefügt haben.
Abe Voelker
599
function read_file(file, delete_after) {
    delete_after = delete_after || "my default here";
    //rest of code
}

Dies wird delete_afterdem Wert zugewiesen,delete_after wenn es sich nicht um einen Falsey- Wert handelt, andernfalls wird die Zeichenfolge zugewiesen"my default here" . Weitere Informationen finden Sie in Doug Crockfords Umfrage zur Sprache und im Abschnitt über Operatoren .

Dieser Ansatz funktioniert nicht, wenn Sie in einem übergeben wollen Falsey Wert , dh false, null, undefined, 0oder "". Wenn Sie die Übergabe von Falsey- Werten benötigen , müssen Sie die Methode in Tom Ritters Antwort verwenden .

Wenn sie mit einer Reihe von Parametern zu einer Funktion zu tun, ist es oft sinnvoll , die Verbraucher zu ermöglichen , 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;
};

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" }); 
Russ Cam
quelle
115
Ich finde das unzureichend, weil ich vielleicht falsch übergeben möchte.
Tom Ritter
52
Ich finde es für die meisten Situationen angemessen
Russ Cam
50
Da es bei Falsey-Werten nicht funktioniert, kann es zu einem Alptraum bei der Wartung kommen. Ein bisschen Code, dem schon immer Wahrheitswerte übergeben wurden und der plötzlich fehlschlägt, weil ein Falsey übergeben wird, sollte wahrscheinlich vermieden werden, wenn ein robusterer Ansatz verfügbar ist.
Jinglesthula
1
Wie kommt es, dass in diesem Fall delete_afterdas boolesche Ergebnis des Ausdrucks nicht erhalten wird delete_after || "my default value"?
Xbonez
3
oder Sie können einfach einen Falsey-Wert verwenden - was im Allgemeinen ohnehin ein guter Standard ist (z. B. false für Bools, leere Zeichenfolge für Zeichenfolgen, 0 für Zahlen usw.) -. In diesem Fall spielt es keine Rolle, was war bestanden in.
Mark Brackett
150

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

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

function myFunc(x) {
  x = pick(x, 'my default');
} 
TJ L.
quelle
6
Update: Wenn Sie underscore.js bereits verwenden, finde ich es noch besser zu verwenden _.defaults(iceCream, {flavor: "vanilla", sprinkles: "lots"});. Die Verwendung des in dieser Antwort gezeigten globalen Namespace wird von vielen als schlechte Praxis angesehen. Sie können auch in Betracht ziehen, Ihr eigenes Dienstprogramm für diese allgemeine Aufgabe zu rollen (z. B. util.default(arg, "defaul value")), wenn Sie keinen Unterstrich verwenden möchten, aber ich verwende meistens früher oder später Unterstrich, um das Rad neu zu erfinden.
andersand
2
Ich empfehle dieses, ich benutze es und nenne es "por", was für "Parameter oder" steht
super
2
Sagen Sie nicht typeof arg == 'undefined', sondern arg === undefined
OsamaBinLogin
3
@OsamaBinLogin, was Sie sagen, ist für das aktuelle JS korrekt - der ältere Test bleibt bestehen, da es in einigen Browsern möglich war, undefinedmit einem anderen Wert zu überschreiben , was dazu führte, dass der Test fehlschlug.
Alnitak
2
@Alnitak: Es ist immer noch möglich, zu überschreiben undefined. Es ist also immer noch eine gute Idee, typeofund zu verwenden 'undefined'.
LS
63

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

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

Dies wird eingestellt delete_after, falsewenn es nicht vorhanden ist oder undefined. Sie können ES6-Funktionen wie diese heute mit Transpilern wie Babel verwenden .

Weitere Informationen finden Sie im MDN-Artikel .

Felix Kling
quelle
1
ECMAScript 6 Ich nehme an ... (Ich hätte es selbst korrigiert, aber ich kann keine Änderungen <6 Zeichen vornehmen)
Zac
1
Warten auf Browser erhalten ECMAScript 6
Adriano Resende
1
Wofür würde Babel das umsetzen?
Harryg
2
@harryg: babeljs.io/repl/…
Felix Kling
2
Hier ist die Kompatibilitätstabelle für ES6 kangax.github.io/compat-table/es6/#default_function_parameters Leider wird diese Syntax noch nicht unterstützt .
Freemanoid
27

Standardparameterwerte

Mit ES6 können Sie möglicherweise eine der häufigsten Redewendungen in JavaScriptBezug auf das Festlegen eines Standardwerts für einen Funktionsparameter ausführen. Die Art und Weise, wie wir dies seit Jahren tun, 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 jedoch gefährlich, wenn wir Werte wie übergeben

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

Warum? Weil das 0 is falsyund damit das x || 11 results in 11nicht direkt in 0 übergeben wird. Um dieses Problem zu beheben, schreiben einige Leute den Scheck stattdessen 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 jetzt eine nette hilfreiche Syntax untersuchen, die ab hinzugefügt wurde ES6, um die Zuweisung von Standardwerten zu fehlenden Argumenten zu optimieren:

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 = 11in einer Funktionsdeklaration ist mehr wie x !== undefined ? x : 11die viel allgemeinere Redewendungx || 11

Standardwertausdrücke

FunctionStandardwerte 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 Standardwertausdrücke träge ausgewertet. Dies bedeutet, dass sie nur ausgeführt werden, wenn sie benötigt werden, dh wenn das Argument eines Parameters weggelassen oder undefiniert ist.

Ein Standardwertausdruck kann sogar ein Inline-Funktionsausdrucksaufruf sein - im Allgemeinen als sofort aufgerufener Funktionsausdruck bezeichnet (IIFE):

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

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

function read_file(file, delete_after) {
    delete_after = delete_after || false;
    // Code
}
Takács Zsolt
quelle
4
Was passiert , wenn delete_afterist 0oder null? In diesen Fällen funktioniert es nicht richtig.
Dmitri Pavlutin
@StephanBijzitter es wäre nur in einigen Fällen wahr. Wenn Sie jedoch nur möchten, dass die Standardwerte die Werte aufheben, hat dies nicht funktioniert, da 0 oder null! === false.
Rutrus
@Rutrus: Ich verstehe nichts, was du gerade gesagt hast.
Stephan Bijzitter
Was ist mit delete_after = delete_after === undefined ? false : delete_after?
Aashah7
10

Verwenden Sie einfach einen expliziten Vergleich mit undefined.

function read_file(file, delete_after)
{
    if(delete_after === undefined) { delete_after = false; }
}
Martin Wantke
quelle
10

Ich würde äußerste Vorsicht empfehlen, wenn Sie Standardparameterwerte in Javascript verwenden. Es schafft oft Fehler , wenn , wie in Verbindung mit Funktionen höherer Ordnung verwendet forEach, mapund reduce. Betrachten Sie beispielsweise diese Codezeile:

['1', '2', '3'].map(parseInt); // [1, NaN, NaN]

parseInt hat einen optionalen zweiten Parameter function parseInt(s, [radix=10]) , ordnet jedoch Aufrufe parseIntmit drei Argumenten zu: ( Element , Index und Array ).

Ich schlage vor, Sie trennen Ihre erforderlichen Parameter von Ihren optionalen / standardmäßigen Argumenten. Wenn Ihre Funktion 1,2 oder 3 erforderliche Parameter verwendet, für die kein Standardwert sinnvoll ist, machen Sie sie zu Positionsparametern für die Funktion. Alle optionalen Parameter sollten als benannte Attribute eines einzelnen Objekts folgen. Wenn Ihre Funktion 4 oder mehr benötigt, ist es möglicherweise sinnvoller, alle Argumente über Attribute eines einzelnen Objektparameters anzugeben.

In Ihrem Fall würde ich vorschlagen, dass Sie Ihre deleteFile-Funktion wie folgt schreiben: ( bearbeitet per instead 's Kommentare ) ...

// unsafe
function read_file(fileName, deleteAfter=false) {
    if (deleteAfter) {
        console.log(`Reading and then deleting ${fileName}`);
    } else {
        console.log(`Just reading ${fileName}`);
    }
}

// better
function readFile(fileName, options) {
  const deleteAfter = !!(options && options.deleteAfter === true);
  read_file(fileName, deleteAfter);
}

console.log('unsafe...');
['log1.txt', 'log2.txt', 'log3.txt'].map(read_file);

console.log('better...');
['log1.txt', 'log2.txt', 'log3.txt'].map(readFile);

Das Ausführen des obigen Snippets zeigt die Gefahren, die hinter Standardargumentwerten für nicht verwendete Parameter lauern.

Doug Coburn
quelle
1
Diese "bessere Lösung" ist nicht lesbar. Ich würde eher empfehlen, den Variablentyp wie zu überprüfen typeof deleteAfter === 'bool'und ansonsten eine Ausnahme auszulösen. Wenn Sie Methoden wie map / foreach usw. verwenden, verwenden Sie diese nur mit Vorsicht und verpacken Sie aufgerufene Funktionen mit anonymen Funktionen. ['1', '2', '3'].map((value) => {read_file(value);})
Stattdessen
Das ist ein guter Punkt. Ich habe versucht, die Verwendung von Bibliotheken in meinem Code-Snippet zu vermeiden, aber diese Redewendung ist in reinem Javascript ziemlich chaotisch. Persönlich würde ich die getMethode von lodash verwenden, um deleteAfter abzurufen. Eine Ausnahme auszulösen, wenn dies typeof 'deleteAfter' !== 'bool'auch eine gute umsichtige Maßnahme sein kann. Ich mag es nicht, Methoden zu entwerfen, bei denen der Aufrufer "Vorsicht walten lassen" muss. Vorsicht liegt in der Verantwortung der Funktion, nicht des Anrufers. Das Endverhalten sollte dem Prinzip der geringsten Überraschung folgen.
Doug Coburn
Ich bin damit einverstanden, dass diese Methode nicht so geschrieben werden sollte, dass das Aufrufen sie dazu bringen kann, ihr Verhalten zu brechen. Beachten Sie jedoch, dass die Funktion wie ein Modell und der Anrufer wie ein Controller ist. Das Modell sollte sich um die Datenverarbeitung kümmern. Funktion (Methode) sollte erwarten, dass Daten falsch übergeben werden können und damit umgehen. Aus diesem Grund ist es am besten, die Art des Parameters zu überprüfen und eine Ausnahme auszulösen. Auch wenn es komplexer ist. Aber es kann dich trotzdem davor bewahren, deinen Kopf zu kratzen und immer wieder zu fragen ... WARUM FUNKTIONIERT ES NICHT?! und dann ... WARUM FUNKTIONIERT ES?!
stattdessen
9

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

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

f(1) === 50

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

zillaofthegods
quelle
11
Diese Antwort ist nicht nützlich, da es sich um ein Duplikat handelt
Benutzer
8

Als langjähriger C ++ - Entwickler (Anfänger in der Webentwicklung :)) habe ich, als ich zum ersten Mal auf diese Situation stieß, die Parameterzuweisung in der Funktionsdefinition wie in der Frage erwähnt wie folgt vorgenommen.

function myfunc(a,b=10)

Beachten Sie jedoch, dass dies in allen Browsern nicht konsistent funktioniert. Für mich funktionierte es auf meinem Desktop mit Chrome, auf Android jedoch nicht mit Chrome. Sicherere Option, wie viele oben erwähnt haben, ist -

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

Die Absicht für diese Antwort ist nicht, die gleichen Lösungen zu wiederholen, die andere bereits erwähnt haben, sondern zu informieren, dass die Parameterzuweisung in der Funktionsdefinition in einigen Browsern möglicherweise funktioniert, sich jedoch nicht darauf verlässt.

vivek
quelle
3
Die Zuweisung innerhalb der Funktionsdefinition funktioniert auch nicht in IE 11, der aktuellsten Version von IE für Windows 8.1.
DiMono
1
Falls sich jemand wundert, function myfunc(a,b=10)ob es sich um eine ES6-Syntax handelt, finden Sie in anderen Antworten Links zu Kompatibilitätstabellen.
Gcampbell
7

Verwenden Sie für alle, die daran interessiert sind, dass dort Code in Microsoft Edge funktioniert, keine Standardeinstellungen für Funktionsparameter.

function read_file(file, delete_after = false) {
    #code
}

In diesem Beispiel gibt Edge den Fehler "Expecting ')'" aus.

Um diese Verwendung zu umgehen

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

Ab dem 08. August 2016 ist dies immer noch ein Problem

Steven Johnston
quelle
4

Gemäß der Syntax

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

Sie können den Standardwert für formale Parameter definieren. Überprüfen Sie auch den undefinierten Wert mithilfe der Funktion typeof .

Sachin Kumar
quelle
4
function helloWorld(name, symbol = '!!!') {
    name = name || 'worlds';
    console.log('hello ' + name + symbol);
}

helloWorld(); // hello worlds!!!

helloWorld('john'); // hello john!!!

helloWorld('john', '(>.<)'); // hello john(>.<)

helloWorld('john', undefined); // hello john!!!

helloWorld(undefined, undefined); // hello worlds!!!
Tính Ngô Quang
quelle
4

Verwenden Sie diese Option, wenn Sie die neueste ECMA6Syntax verwenden möchten :

function myFunction(someValue = "This is DEFAULT!") {
  console.log("someValue --> ", someValue);
}

myFunction("Not A default value") // calling the function without default value
myFunction()  // calling the function with default value

Es heißt default function parameters. Es ermöglicht die Initialisierung formaler Parameter mit Standardwerten, wenn kein Wert oder undefiniert übergeben wird. HINWEIS : Es funktioniert nicht mit Internet Explorer oder älteren Browsern.

Verwenden Sie für maximale Kompatibilität Folgendes:

function myFunction(someValue) {
  someValue = (someValue === undefined) ? "This is DEFAULT!" : someValue;
  console.log("someValue --> ", someValue);
}

myFunction("Not A default value") // calling the function without default value
myFunction()  // calling the function with default value

Beide Funktionen haben genau das gleiche Verhalten wie jedes dieser Beispiele. Dies hängt davon ab, dass die Parametervariable lautet, undefinedwenn beim Aufrufen dieser Funktion kein Parameterwert übergeben wurde.

BlackBeard
quelle
HINWEIS: Wie @BlackBeard sagt, funktioniert die Funktion (param = value) NICHT mit dem IE. Verwenden Sie die kompatible Version.
MagicLAMP
4

ES6: Wie bereits in den meisten Antworten erwähnt, können Sie in ES6 einfach einen Parameter zusammen mit einem Wert initialisieren.


ES5: Die meisten der gegebenen Antworten sind nicht gut genug für mich , denn es gibt Gelegenheiten , wo ich zu können Falsey Werte wie passieren 0, nullund undefinedzu einer Funktion. Um festzustellen, ob ein Parameter undefiniert ist, weil dies der Wert ist, den ich anstelle von undefiniert übergeben habe, weil er überhaupt nicht definiert wurde, gehe ich folgendermaßen vor:

function foo (param1, param2) {
   param1 = arguments.length >= 1 ? param1 : "default1";
   param2 = arguments.length >= 2 ? param2 : "default2";
}
Engel Politis
quelle
3

function throwIfNoValue() {
throw new Error('Missing argument');
}
function foo(argValue = throwIfNoValue()) {
return argValue ;
}

Hier ist foo () eine Funktion mit einem Parameter namens argValue. Wenn wir hier im Funktionsaufruf nichts übergeben, wird die Funktion throwIfNoValue () aufgerufen und das zurückgegebene Ergebnis dem einzigen Argument argValue zugewiesen. So kann ein Funktionsaufruf als Standardparameter verwendet werden. Das macht den Code einfacher und lesbarer.

Dieses Beispiel wurde von hier genommen

Dutta
quelle
3

Wenn Sie verwenden ES6+, können Sie Standardparameter wie folgt einstellen:

function test (foo = 1, bar = 2) {
  console.log(foo, bar);
}

test(5); // foo gets overwritten, bar remains default parameter

Wenn Sie eine ES5Syntax benötigen , können Sie dies folgendermaßen tun:

function test(foo, bar) {
  foo = foo || 2;
  bar = bar || 0;
  
  console.log(foo, bar);
}

test(5); // foo gets overwritten, bar remains default parameter

In der obigen Syntax wird der OROperator verwendet. Der OROperator gibt immer den ersten Wert zurück, wenn dieser konvertiert werden kann, truewenn nicht, gibt er den rechten Wert zurück. Wenn die Funktion ohne entsprechendes Argument aufgerufen wird, wird die Parametervariable ( barin unserem Beispiel) undefinedvon der JS-Engine auf gesetzt. undefinedWird dann in false konvertiert und gibt der OROperator somit den Wert 0 zurück.

Willem van der Veen
quelle
3

Ja, die Verwendung von Standardparametern wird in ES6 vollständig unterstützt :

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

oder

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

Vor ES5 war dies jedoch problemlos möglich:

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

Das heißt, wenn der Wert vorhanden ist, verwenden Sie den Wert, andernfalls verwenden Sie den zweiten Wert nach der ||Operation, der dasselbe tut ...

Hinweis: Es gibt auch einen großen Unterschied zwischen diesen, wenn Sie einen Wert an ES6 übergeben , selbst wenn der Wert falsch ist, der durch einen neuen Wert ersetzt wird, etwa nulloder ""... aber ES5 1 wird nur ersetzt, wenn nur der übergebene Wert ist wahr, das liegt daran, wie die ||Arbeitsweise ...

Alireza
quelle
2

Wenn aus irgendeinem Grund Sie sind nicht auf ES6 und sind mit lodashhier ist eine kurze Art und Weise Funktionsparameter über auf die _.defaultToStandardmethode:

var fn = function(a, b) {
  a = _.defaultTo(a, 'Hi')
  b = _.defaultTo(b, 'Mom!')

  console.log(a, b)
}

fn()                 // Hi Mom!
fn(undefined, null)  // Hi Mom!
fn(NaN, NaN)         // Hi Mom!
fn(1)                // 1 "Mom!"
fn(null, 2)          // Hi 2
fn(false, false)     // false false
fn(0, 2)             // 0 2
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.min.js"></script>

Hiermit wird der Standardwert festgelegt, wenn der aktuelle Wert NaN , null oder undefiniert ist

Akrion
quelle
1

Klänge der Zukunft

In Zukunft können Sie ein Objekt auf ein anderes "verteilen" (derzeit ab 2019 NICHT von Edge unterstützt !) - eine Demonstration, wie Sie dies für nette Standardoptionen unabhängig von der Reihenfolge verwenden können:

function test(options) {
    var options = {
       // defaults
       url: 'defaultURL',
       some: 'somethingDefault',
       // override with input options
       ...options
    };
    
    var body = document.getElementsByTagName('body')[0];
    body.innerHTML += '<br>' + options.url + ' : ' + options.some;
}
test();
test({});
test({url:'myURL'});
test({some:'somethingOfMine'});
test({url:'overrideURL', some:'andSomething'});
test({url:'overrideURL', some:'andSomething', extra:'noProblem'});

MDN-Referenz: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax

... währenddessen unterstützt Edge DOES Object.assign () (IE nicht, aber ich hoffe wirklich, dass wir IE zurücklassen können :))

Ebenso könnten Sie tun

    function test(options) {
        var options = Object.assign({
           // defaults
           url: 'defaultURL',
           some: 'somethingDefault',
        }, options); // override with input options
        
        var body = document.getElementsByTagName('body')[0];
        body.innerHTML += '<br>' + options.url + ' : ' + options.some;
    }
    test();
    test({});
    test({url:'myURL'});
    test({some:'somethingOfMine'});
    test({url:'overrideURL', some:'andSomething'});
    test({url:'overrideURL', some:'andSomething', extra:'noProblem'});

BEARBEITEN: Aufgrund von Kommentaren zu constOptionen - das Problem bei der Verwendung konstanter Optionen im Rest der Funktion besteht eigentlich nicht darin, dass Sie dies nicht tun können, sondern nur darin, dass Sie die konstante Variable nicht in ihrer eigenen Deklaration verwenden können - hätten Sie um die Eingangsbenennung an etwas wie anzupassen

function test(input_options){
   const options = {
     // defaults
     someKey:    'someDefaultValue',
     anotherKey: 'anotherDefaultValue',

     // merge-in input options
     ...input_options
   };

   // from now on use options with no problem
}
jave.web
quelle
Das Problem ist, dass Sie dies normalerweise nie tun möchten, da dadurch bereits definierte Optionen neu zugewiesen werden, Sie sie jedoch mit einer anderen var verwenden können, die legitim wäre.
Frank-Dspeed
Funktionstest (Optionen) {/ * Optionen ist definiert, es wird ein Fehler
ausgelöst,
nein nicht global, wenn Sie eine Funktion erstellen und als Argumentname Optionen übergeben, dann innerhalb der Funktion Optionen innerhalb der Funktion definiert sind (opt) {} opt ist definiert Sie können const opt ​​nicht innerhalb dieser Funktion verwenden, dann ist dies schlecht, weil Sie dies tun Variable Neuzuweisung, wenn Sie das oft tun und es wie Ihr allgemeines Muster aussieht, ist dies ein Problem
frank-dspeed
@ google-frank-dspeed ah, meinst du das kannst du nicht function(opt){ const opt = /*some merging*/; }? Das wird sicher nicht funktionieren, da Sie eine constVariable verwenden würden , bevor sie deklariert wurde - Sie müssten anpassen -function test(input_opt){ const opt = { someKey: 'someDefaultValue', ...input_opt} }
jave.web
@ google-frank-dspeed sowieso werden sich wahrscheinlich mehr neue Leute darüber wundern, also habe ich den zu bearbeitenden How-to-Code hinzugefügt :)
Also
1

Um auch meine Fähigkeiten zu demonstrieren (lol), kann die obige Funktion auch ohne die folgenden Argumente geschrieben werden:

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';
    ...
}
Shivang Gupta
quelle
0
def read_file(file, delete_after = false)
  # code
end

Der folgende Code funktioniert möglicherweise in dieser Situation, einschließlich ECMAScript 6 (ES6) sowie früherer Versionen.

function read_file(file, delete_after) {
    if(delete_after == undefined)
        delete_after = false;//default value

    console.log('delete_after =',delete_after);
}
read_file('text1.txt',true);
read_file('text2.txt');

Der Standardwert in Sprachen funktioniert, wenn der Parameterwert der Funktion beim Aufruf übersprungen wird. In JavaScript wird er undefiniert zugewiesen . Dieser Ansatz sieht programmatisch nicht attraktiv aus, ist jedoch abwärtskompatibel .

Muhammad Rizwan
quelle
0

Ja, dies wird als Standardparameter bezeichnet

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

Syntax:

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

Beschreibung:

Die Parameter der Funktionen sind standardmäßig undefiniert. In Situationen kann es jedoch hilfreich sein, einen anderen Standardwert festzulegen. Hier können Standardparameter helfen.

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

Mit den Standardparametern in ES2015 ist die Überprüfung im Funktionskörper nicht mehr erforderlich. Jetzt können Sie einfach einen Standardwert in den Funktionskopf einfügen.

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 Syntaxbeispiele:

Auffüllen undefiniert gegen andere falsche Werte:

Selbst wenn der Wert beim Aufruf explizit festgelegt wird, ist der Wert des Argumentes 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)

Zum Zeitpunkt des Anrufs ausgewertet:

Das Standardargument wird beim Aufruf ausgewertet. Im Gegensatz zu einigen anderen Sprachen wird bei jedem Aufruf der Funktion ein neues Objekt erstellt.

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 stehen für spätere Standardparameter zur Verfügung:

Bereits angetroffene Parameter stehen späteren Standardparametern zur Verfügung

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.')

Im Funktionskörper definierte Funktionen:

Eingeführt in Gecko 33 (Firefox 33 / Thunderbird 33 / SeaMonkey 2.30). Im Funktionskörper deklarierte Funktionen können nicht innerhalb der Standardparameter referenziert werden und lösen einen ReferenceError aus (derzeit ein TypeError in SpiderMonkey, siehe Fehler 1022967). Standardparameter werden immer zuerst ausgeführt, Funktionsdeklarationen innerhalb des Funktionskörpers werden anschließend ausgewertet.

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

Parameter ohne Standardwerte nach 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 im Fehler 777060 behoben und funktioniert wie erwartet in späteren Versionen. Die Parameter werden weiterhin von links nach rechts festgelegt, wodurch Standardparameter überschrieben werden, auch wenn spätere Parameter ohne Standardwerte vorhanden sind.

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

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

Zerstörter Parameter mit Standardwertzuweisung:

Sie können die Standardwertzuweisung mit der Notation der Destrukturierungszuweisung verwenden

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

f(); // 6
esewalson
quelle
0

Ein anderer Ansatz zum Festlegen von Standardparametern besteht darin, die Objektzuordnung von Argumenten anstelle von Argumenten direkt zu verwenden. 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 die Nichtübereinstimmung der Argumentlänge zu machen.

Aman Pandey
quelle
-1

Die Antwort ist ja. Tatsächlich gibt es viele Sprachen, die Standardparameter unterstützen. Python ist einer von ihnen:

def(a, enter="Hello"):
   print(a+enter)

Obwohl dies aufgrund der Klammern Python 3-Code ist, funktionieren Standardparameter in Funktionen auch in JS.

Zum Beispiel und in Ihrem Fall:

function read_file(file, deleteAfter=false){
  console.log(deleteAfter);
}

read_file("test.txt");

Aber manchmal brauchen Sie nicht wirklich Standardparameter.

Sie können die Variable direkt nach dem Start der Funktion wie folgt definieren:

function read_file(file){
  var deleteAfter = false;
  console.log(deleteAfter);
}

read_file("test.txt");

In beiden meiner Beispiele wird dasselbe zurückgegeben. Aber manchmal können sie tatsächlich nützlich sein, wie in sehr fortgeschrittenen Projekten.

Zusammenfassend können also Standardparameterwerte in JS verwendet werden. Es ist jedoch fast dasselbe wie das Definieren einer Variablen direkt nach dem Start der Funktion. Manchmal sind sie jedoch immer noch sehr nützlich. Wie Sie vielleicht bemerkt haben, benötigen Standardparameterwerte 1 Codezeile weniger als die Standardmethode, mit der der Parameter direkt nach dem Start der Funktion definiert wird.

EDIT: Und das ist super wichtig! Dies wird nicht in IE arbeiten. Siehe Dokumentation . Im IE müssen Sie also die Methode "Variable oben in der Funktion definieren" verwenden. Standardparameter funktionieren im IE nicht.

Zixuan
quelle
-3

Ja, dies funktioniert in Javascript. Sie können das auch tun:

function func(a=10,b=20)
{
    alert (a+' and '+b);
}

func(); // Result: 10 and 20

func(12); // Result: 12 and 20

func(22,25); // Result: 22 and 25
Muhammad Awais
quelle
2
Es ist derzeit nicht portabel ... IE ... developer.mozilla.org/en/docs/Web/JavaScript/Reference/… (Und es ist eine doppelte Antwort ...)
Gert van den Berg