Vraag Stel een standaard parameterwaarde in voor een JavaScript-functie


Ik zou graag willen dat een JavaScript-functie optionele argumenten heeft waarvoor ik een standaard inschakel, die wordt gebruikt als de waarde niet is gedefinieerd. In Ruby kun je het als volgt doen:

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

Werkt dit in JavaScript?

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

2017
2018-05-21 20:07


oorsprong


antwoorden:


Vanaf ES6 / ES2015 staan ​​de standaardparameters in de taalspecificatie.

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

werkt gewoon.

Referentie: Standaardparameters - MDN

Met standaardfunctieparameters kunnen formele parameters worden geïnitialiseerd met standaardwaarden indien geen waarde of onbepaald is geslaagd.

Je kan ook simuleer standaard genaamd parameters via destructuring:

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

Er zijn veel manieren, maar dit is mijn voorkeursmethode - je kunt alles doorgeven wat je wilt, inclusief false of 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
}

Dit wijst toe aan delete_after de waarde van delete_after als het geen is falsey waarde anders wijst het de string toe "my default here". Raadpleeg voor meer informatie Doug Crockford's overzicht van de taal en bekijk de sectie over Operators.

Deze aanpak werkt niet als u wilt doorgeven in a falsey waarde i.e. false, null, undefined, 0 of "". Als je nodig hebt falsey waarden die moeten worden doorgegeven, zouden de methode moeten gebruiken Tom Ritter's antwoord.

Wanneer het gaat om een ​​aantal parameters voor een functie, is het vaak nuttig om de gebruiker toe te staan ​​de parameterargumenten in een object en vervolgens door te geven samensmelten deze waarden met een object dat de standaardwaarden voor de functie bevat

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

gebruiken

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



Ik vind zoiets simpels om persoonlijk veel beknopter en leesbaarder te zijn.

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 kun je precies schrijven wat je hebt:

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

Dit zal instellen delete_after naar false als het niet aanwezig is of undefined. U kunt vandaag ES6-functies zoals deze gebruiken met transpilers zoals Babel.

Zie het MDN-artikel voor meer informatie.


54
2018-05-29 15:25



Standaard parameterwaarden

Met ES6 kun je misschien een van de meest voorkomende uitdrukkingen gebruiken JavaScript heeft betrekking op het instellen van een standaardwaarde voor een functieparameter. De manier waarop we dit al jaren doen, zou er heel bekend uit moeten zien:

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

Dit patroon wordt het meest gebruikt, maar is gevaarlijk wanneer we waarden zoals doorgeven

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

Waarom? Omdat het 0 is falsy, en zo de x || 11 results in 11, niet het direct doorgegeven in 0. Om dit te repareren, zullen sommige mensen de cheque in plaats daarvan meer als volgt schrijven:

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

we kunnen nu een mooie nuttige syntaxis bekijken die toegevoegd is vanaf ES6 om de toewijzing van standaardwaarden naar ontbrekende argumenten te stroomlijnen:

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 een functie-declaratie lijkt meer x !== undefined ? x : 11 dan het veel gebruikelijkere idioom x || 11

Standaardwaarde Expressies

Function standaardwaarden kunnen meer zijn dan alleen eenvoudige waarden zoals 31; ze kunnen elke geldige uitdrukking zijn, zelfs een 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

Zoals u kunt zien, worden de uitdrukkingen van de standaardwaarde traag geëvalueerd, wat betekent dat ze alleen worden uitgevoerd als en wanneer ze nodig zijn - dat wil zeggen, als het argument van een parameter wordt weggelaten of ongedefinieerd is.

Een standaardwaarde-uitdrukking kan zelfs een inline-functiexpressie-aanroep zijn - gewoonlijk aangeduid als een onmiddellijk aanroepende functie-uitdrukking (IIFE):

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

18
2017-10-15 17:58



die oplossing is werk voor mij in js:

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

8
2017-11-16 11:29



Gebruik gewoon een expliciete vergelijking met undefined.

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

6
2017-11-16 07:34