Seta un parametru implicit valoare pentru o funcție JavaScript

De ES6/ES2015, implicit parametrii sunt în limba caietul de sarcini.

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

pur și simplu funcționează.

Referință: Default Parametri - MDN

Implicit de parametrii de funcționare permite parametrii formali să fie inițializate cu valorile implicite dacă valoare sau nedefinit este trecut.

Puteți, de asemenea, simula implicit nume parametrii prin destructurare:

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

Există o mulțime de moduri, dar aceasta este metoda mea preferată — acesta vă permite să treacă în orice vrei, inclusiv false sau null. (typeof null == "obiect")

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
}

Acest atribuie delete_after valoarea delete_after dacă aceasta nu este o falsey valoare în caz contrar se atribuie șirul "implicit aici". Pentru mai multe detalii, a verifica afară Doug Crockford's studiului limbii și a verifica afară de secțiunea pe Operatorii.

Această abordare nu funcționează dacă vrei să treci într-o falsey valoarea anume false, null, nedefinit, 0 sau "". Dacă ai nevoie de falsey valori să fie trecut în tine ar trebui să utilizați metoda în Tom Ritter's a răspunde.

Atunci când se ocupă cu o serie de parametri pentru o funcție, este de multe ori util pentru a permite consumatorului să treacă parametru argumente într-un obiect și apoi merge aceste valori cu un obiect care conține valorile implicite pentru funcția

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

pentru a utiliza

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

Am găsit ceva simplu ca acest lucru să fie mult mai concis și ușor de citit personal.

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

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

În ECMAScript 6 va fi de fapt în măsură să scrie exact ceea ce trebuie:

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

Acest lucru se va stabili delete_after a "fals" dacă nu e prezentă sau "nedefinit". Puteți folosi caracteristici ES6 ca aceasta de azi cu transpilers precum Babel.

Vezi MDN articolul pentru mai multe informații.

Implicit Valorile Parametrilor

Cu ES6, puteți face, probabil, una dintre cele mai comune expresii în "JavaScript" se referă la setarea o valoare implicită pentru o funcție parametru. La fel cum am făcut acest lucru de ani de zile ar trebui să arate destul de familiar:

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

Acest model este cel mai folosit, dar este periculos atunci când vom trece de valori, cum ar fi

foo(0, 42)
foo( 0, 42 ); // 53 

această soluție este de lucru pentru mine în js:

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

Doar folosi o comparație explicită cu nedefinite.

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

Ca un update...cu ECMAScript 6 puteți în cele din URMĂ set de valori implicite în funcție declarațiilor parametrilor astfel:

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

f(1) === 50

Ca referite printr - http://es6-features.org/#DefaultParameterValues

Mi-ar recomanda foarte extremă prudență atunci când se utilizează implicit valorile parametrilor în javascript. Acesta creează de multe ori bug-uri atunci când este utilizat în conjuncție cu funcții de ordin superior, ca "forEach", "harta", și "reduce". De exemplu, ia în considerare această linie de cod:

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

parseInt a, opțional, un al doilea parametru functia parseInt(s, [radix=10]) dar harta apeluri `parseInt cu trei argumente: (element, index, și array).

Îți sugerez să-ți separi parametri necesari forma opțională/default evaluate argumentele. Dacă funcția are 1,2, sau 3 parametri necesari pentru care nu există valoare implicită sens, le face pozițional parametrii funcției, orice parametri opționali ar trebui să urmeze ca nume de atribute ale unui singur obiect. Dacă funcția are 4 sau mai multe, poate face mai mult sens să furnizeze toate argumentele prin atributele unui singur obiect parametru.

În cazul tău, aș sugera să scrie deleteFile funcție de genul asta: (editat pe "în loc" 's comentarii)...

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

Rularea de mai sus fragmentul ilustrează pericolele spectatori în spatele default argument valorile neutilizate parametri.

fiind o lungă perioadă de timp C++ developer (Începător de dezvoltare web :)), prima dată când am dat peste această situație, am făcut misiune parametru în funcție de definiție, așa cum este menționat în întrebare, după cum urmează.

function myfunc(a,b=10)

Dar feriți-vă că aceasta nu't lucra în mod constant pe diferite browsere. Pentru mine a functionat pe chrome pe desktop-ul meu, dar nu au de lucru pe chrome de pe android. Opțiune mai sigură, după cum au menționat mai sus este -

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

Intenția pentru acest răspuns nu este de a repeta aceleași soluții, ceea ce alții au menționat deja, dar pentru a informa că atribuirea parametrilor în funcție de definiție poate lucra pe unele browsere, dar don't să se bazeze pe ea.

Pentru oricine este interesat în a avea acolo codul muncă în Microsoft Edge, nu folosi valori implicite în funcție de parametrii.

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

În acest exemplu Edge va arunca o eroare "Așteaptă ')'"

Pentru a obține în jurul valorii de această utilizare

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

Ca din Aug 08 2016 acest lucru este încă o problemă

Ca pe sintaxa

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

puteți defini valoarea implicită de parametri formali. și, de asemenea, a verifica valoare nedefinită, prin utilizarea tip funcția.

ES6: după Cum sa menționat deja, în cele mai multe răspunsuri, în ES6, pur și simplu, puteți inițializa un parametru de-a lungul cu o valoare.

ES5: cele Mai multe dintre răspunsurile date sunt't suficient de bun pentru mine, pentru că sunt situații în care am putea avea să treacă falsey valori, cum ar fi 0, null și "nedefinit" la o funcție. Pentru a determina dacă un parametru este de nedefinit pentru că's valoarea am trecut în loc de nedefinit din cauza nu au fost definite la toate am face acest lucru:

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

Utilizați această opțiune dacă doriți să utilizați cea mai recentă ECMA6 sintaxa:

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

Este numit default funcție parameters. Acesta vă permite parametrii formali să fie inițializate cu valorile implicite dacă nici o valoare sau nedefinit este trecut. NOTĂ: obiceiul de lucru cu Internet Explorer sau browsere mai vechi.

Pentru maxim posibil **** compatibilitate folosi asta:

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

Ambele funcții au exact acelasi comportament ca fiecare dintre aceste exemple se bazează pe faptul că parametrul variabilă va fi "nedefinit" dacă nici o valoare de parametru a fost trecut când apelați această funcție.

Da, folosind parametrii implicit este pe deplin susținută în ES6:

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

sau

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

dar înainte de în ES5 ai putea face cu ușurință acest lucru:

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

Ceea ce înseamnă că dacă valoarea este acolo, utilizați valoarea, în caz contrar, utilizați cea de-a doua valoare după || operațiune care face acelasi lucru...

Notă: de asemenea, există o mare diferență între cei care, dacă treci de o valoare ES6 unul chiar valoarea fi falsy, care va fi înlocuită cu noua valoare, ceva de genul nul sau ""... dar **ES5** una singura va fi înlocuite numai dacă a trecut de valoare este sinceră, care's pentru modul||` lucru...

Dacă utilizați ES6+ puteți seta parametrii impliciți în felul următor:

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

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

Dacă ai nevoie de ES5` sintaxa poți face în felul următor:

function test(foo, bar) {
  foo = foo || 2;
  bar = bar || 0;

  console.log(foo, bar);
}

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

În cele de mai sus sintaxa " SAU " operator este folosit. La " SAU "operator întotdeauna se întoarce prima valoare dacă acest lucru poate fi convertit la "true" dacă nu se întoarce righthandside valoare. Atunci când funcția este numit cu nici un argument corespunzătoare parametrul variabilă ("bar", în exemplul nostru) este setat la "nedefinit" prin motorului JS. "nedefinit" Este apoi convertit în false și, astfel, face " SAU " operator returna valoarea 0.

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

Aici foo() este o funcție care are un parametru numit argValue. Dacă nu vom trece de nimic în apelul funcției aici, atunci funcția throwIfNoValue() va fi numit și întors rezultatul va fi repartizat la singurul argument argValue. Acesta este modul în care un apel de funcție poate fi folosit ca un parametru implicit. Ceea ce face codul mai simplificat și ușor de citit.

Acest exemplu a fost luat de aici

Dacă pentru un motiv oarecare nu sunt nu pe ES6 și sunt utilizarea lodash aici este un mod concis de a default funcție de parametrii prin intermediul _.defaultTo metoda:

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>

Care va stabili implicit în cazul în care valoarea actuală este NaN, null, sau nedefinit

Da acest lucru este menționat ca un parametru implicit

Default funcție de parametrii permite parametrii formali să fie inițializate cu valorile implicite dacă nici o valoare sau nedefinit este trecut.

Sintaxa:

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

Descriere:

Parametri de funcții implicite pentru nedefinite cu toate Acestea, în situații ar putea fi util pentru a seta o valoare implicită. Acest lucru este în cazul în care implicit parametrii pot ajuta.

În trecut, strategia generală pentru stabilirea implicite a fost de a testa valorile parametrilor în corpul funcției și atribui o valoare, dacă acestea sunt nedefinite. Dacă nicio valoare nu este prevăzută în apel, valoarea acesteia va fi nedefinit. Tu ar trebui să stabilească un condiționată asigurați-vă că parametrul nu este nedefinit

Cu parametrii impliciți în ES2015, check-in funcția de organism nu mai este necesar. Acum puteți pune pur și simplu o valoare implicită în funcție cap.

Exemplu de deosebiri:

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

Sintaxă Diferită Exemple:

Padding nedefinit vs alte falsy valori:

Chiar dacă valoarea este setată în mod explicit atunci când de asteptare, valoarea num argument este cel implicit.

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)

Evaluate la timp de apel:

Implicit argument se evaluează în timpul apelului, astfel încât spre deosebire de alte limbi, un nou obiect este creat de fiecare dată când funcția este apelată.

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

Implicit parametrii sunt disponibile pentru mai târziu, default parametri:

Params deja întâlnite sunt disponibile pentru mai târziu, default parametri

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

Funcții definite în interiorul corpului funcției:

Introdus în Gecko 33 (Firefox 33 / Thunderbird 33 / Mozilla 2.30). Funcțiile declarate în corpul funcției nu pot fi prevăzute în interiorul default parametri și arunca o ReferenceError (în prezent, un TypeError în SpiderMonkey, vezi bug 1022967). Implicit parametrii sunt întotdeauna executate în primul rând, declarațiile funcțiilor în interiorul corpului funcției evalua după aceea.

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

Parametri fără implicite după default parametri:

Înainte de Gecko 26 (Firefox 26 / Thunderbird 26 / Mozilla 2.23 / Firefox OS 1.2), codul de mai jos a dus la o SyntaxError. Acest lucru a fost stabilit în bug 777060 și funcționează cum era de așteptat în versiunile ulterioare. Parametrii sunt stabili încă de la stânga la dreapta, suprascrierea default parametri, chiar dacă există mai tarziu parametri fără implicite.

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

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

Destructurarea paramet cu default atribuirea valorii:

Puteți utiliza valoarea implicită misiune cu misiunea de destructurare notație

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

f(); // 6