without - javascript pass variable to function




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

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

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

Funktioniert das in JavaScript?

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

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

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

f(1) === 50

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


Als langjähriger C ++ - Entwickler (Rookie für Webentwicklung :)), als ich zum ersten Mal auf diese Situation gestoßen bin, habe ich die Parametrierung in der Funktionsdefinition vorgenommen, wie in der Frage erwähnt, wie folgt.

function myfunc(a,b=10)

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

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

Diese Antwort soll nicht die gleichen Lösungen wiederholen, die andere bereits erwähnt haben, sondern dass die Parametrierung in der Funktionsdefinition in einigen Browsern funktionieren kann, sich aber nicht darauf verlassen kann.


Ich würde äußerste Vorsicht empfehlen, wenn Sie Standardparameterwerte in Javascript verwenden. Es erzeugt häufig Fehler, wenn es in Verbindung mit Funktionen höherer Ordnung wie forEach , map und reduce . Betrachten Sie zum Beispiel diese Codezeile:

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

parseInt verfügt über eine optionale zweite Parameterfunktion function parseInt(s, [ radix =10]) , parseInt Aufrufe von parseInt mit drei Argumenten zu: ( Element , Index und Array ).

Ich empfehle Ihnen, Ihre erforderlichen Parameter von Ihren optionalen / Standardwertargumenten zu trennen. Wenn für Ihre Funktion 1, 2 oder 3 erforderliche Parameter erforderlich sind, für die kein Standardwert sinnvoll ist, machen Sie sie zur Positionsposition, und 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 bereitzustellen.

In Ihrem Fall würde ich vorschlagen, dass Sie die deleteFile-Funktion folgendermaßen schreiben:

// 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 = false } = options || {}; // if null
  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 veranschaulicht die Gefahren, die hinter den Standardargumentwerten für nicht verwendete Parameter lauern.


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

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

Dies setzt delete_after auf false wenn es nicht vorhanden oder undefined . Sie können ES6-Funktionen wie diese heute mit Transpirern wie Babel .

Weitere Informationen finden Sie im MDN-Artikel .


Ja, das wird als Standardparameter bezeichnet

Mit Standardfunktionsparametern können Formalparameter mit Standardwerten initialisiert werden, wenn kein Wert oder undefined übergeben wird.

Syntax:

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

Beschreibung:

Funktionsparameter standardmäßig auf undefined In bestimmten Situationen kann es jedoch nützlich sein, einen anderen Standardwert festzulegen. Hier können Standardparameter helfen.

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

Mit den Default-Parametern in ES2015 ist die Überprüfung im Funktionsrumpf nicht mehr erforderlich. Jetzt können Sie einfach einen Standardwert in den Funktionskopf eingeben.

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:

Padding undefined gegen andere Falschwerte:

Auch wenn der Wert beim Aufruf explizit festgelegt wird, ist der Wert des Arguments nummer 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 Anrufzeitpunkt bewertet:

Das Standardargument wird zum Zeitpunkt des Aufrufs ausgewertet. Im Gegensatz zu 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 sind für spätere Standardparameter verfügbar:

Bereits angetroffene Parameter stehen für spätere Standardparameter 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.')

Funktionen innerhalb des Funktionskörpers definiert:

Eingeführt in Gecko 33 (Firefox 33 / Thunderbird 33 / SeaMonkey 2.30). Funktionen, die im Funktionshauptteil deklariert sind, können nicht innerhalb von Standardparametern referenziert werden und werfen 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 in Bug 777060 behoben und funktioniert in späteren Versionen wie erwartet. Die Parameter werden immer noch von links nach rechts gesetzt, wodurch die 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örtes Parameter mit Standardwertzuweisung:

Sie können die Standardwertzuordnung mit der Notierungsfunktion für die Destrukturierung verwenden

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

f(); // 6

Ja, das wird in Javascript funktionieren. 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

Verwenden Sie einfach einen expliziten Vergleich mit undefined.

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

Verwenden Sie für alle, die daran interessiert sind, dass Code in Microsoft Edge funktioniert, keine Standardwerte in Funktionsparametern.

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

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

Um diese Verwendung zu umgehen

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

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


Wenn Sie sich aus irgendeinem Grund nicht auf ES6 befinden und lodash , können Sie die Funktionsparameter _.defaultTo Methode _.defaultTo Weise _.defaultTo :

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>

Welches ist der Standardwert, wenn der aktuelle Wert NaN , Null oder nicht definiert ist


Wie in der Syntax

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

Sie können den Standardwert von Formalparametern definieren. Überprüfen Sie auch undefinierte Werte mithilfe der typeof- Funktion.


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

ES5: Die meisten der angegebenen Antworten sind für mich nicht gut genug, da es gelegentlich vorkommt, dass ich Falsey-Werte wie 0 , null und undefined an eine Funktion übergeben muss. Um festzustellen, ob ein Parameter undefiniert ist, weil dies der Wert ist, den ich übergeben habe und nicht, weil er überhaupt nicht definiert wurde.

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

Standardparameterwerte

Mit ES6 können Sie vielleicht eine der gebräuchlichsten Ausdrücke in JavaScript , wenn Sie einen Standardwert für einen Funktionsparameter festlegen. Die Art und Weise, 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 jedoch gefährlich, wenn Werte wie übergeben werden

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

Warum? Weil die 0 is falsy , und so ist das x || 11 results in 11 x || 11 results in 11 und nicht direkt zu 0. 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 ES6 hinzugefügt wurde, um die Zuweisung von Standardwerten zu fehlenden Argumenten 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 x !== undefined ? x : 11 als die viel gebräuchlichere Ausdrucksweise x || 11 x || 11

Standardwertausdrücke

Function 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 träge ausgewertet, dh sie werden nur dann ausgeführt, wenn sie benötigt werden - das heißt, wenn das Argument eines Parameters ausgelassen wird oder undefiniert ist.

Ein Standardwertausdruck kann sogar ein Aufruf eines Inline-Funktionsausdrucks sein, der im Allgemeinen als "Direkt aufgerufener Funktionsausdruck" (IIFE) :

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

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

Der folgende Code kann in dieser Situation funktionieren, einschließlich ECMAScript 6 (ES6) sowie früheren 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');

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


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




default-parameters