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

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

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

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

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 .

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

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

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

Verwenden Sie einfach einen expliziten Vergleich mit undefined.

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

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.

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

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.

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

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 .

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

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.

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

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

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.

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

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

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
}

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

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 .

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

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.

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.

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