Ustawianie domyślnej wartości parametru dla funkcji JavaScript

function read_file(file, delete_after) {
    delete_after = delete_after || "my default here";
    //rest of code
}

To przypisuje delete_after wartość delete_after Jeśli nie jest to wartość false, w przeciwnym razie przypisuje łańcuch "my default here". Aby uzyskać więcej szczegółów, sprawdź Badanie języka Douga Crockforda i sprawdź sekcję dotyczącą operatorów.

To podejście nie działa, jeśli chcesz przekazać false wartość tj. false, null, undefined, 0 lub "". Jeśli potrzebujesz false wartości, które mają być przekazywane w, Musisz użyć metody w Tom Odpowiedź Rittera .

Kiedy mamy do czynienia z wieloma parametrami do funkcji, często przydatne jest umożliwienie konsumentowi przekazania argumentów parametru w obiekcie, a następnie scalenie tych wartości z obiektem, który zawiera domyślne wartości dla funkcji

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

Do użycia

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

[1]}uważam, że coś prostego, jak to, jest znacznie bardziej zwięzłe i czytelne osobiście.

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

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

W ECMAScript 6 będziesz w stanie napisać dokładnie to, co masz:

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

Ustawia delete_after na false, jeśli nie występuje lub undefined. Możesz używać funkcji ES6 takich jak ta dzisiaj z transpilerami, takimi jak Babel .

Więcej informacji można znaleźć w artykule MDN .

Domyślne Wartości Parametrów

Z ES6, można zrobić prawdopodobnie jeden z najczęstszych idiomów w JavaScript odnosi się do ustawiania wartości domyślnej dla parametru funkcji. Sposób, w jaki robiliśmy to od lat, powinien wyglądać dość znajomo: {]}

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

Ten wzór jest najczęściej używany, ale jest niebezpieczny, gdy przekazujemy wartości takie jak

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

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

Możemy teraz sprawdzić przydatną składnię dodaną od ES6, aby usprawnić przypisywanie wartości domyślnych do brakujących argumentów:

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 w deklaracji funkcji jest bardziej podobny x !== undefined ? x : 11 niż znacznie bardziej powszechny idiom x || 11

Wyrażenia Wartości Domyślnej

Function wartości domyślne mogą być czymś więcej niż tylko prostymi wartościami, takimi jak 31; mogą być dowolnym poprawnym wyrażeniem, nawet 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

As you domyślne wyrażenia wartości są leniwie oceniane, co oznacza, że są uruchamiane tylko wtedy, gdy są potrzebne - to znaczy, gdy argument parametru jest pominięty lub niezdefiniowany.

Domyślnym wyrażeniem wartości może być nawet wywołanie funkcji inline - powszechnie określane jako natychmiast wywołane wyrażenie funkcji (IIFE):

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

To rozwiązanie działa dla mnie w js:

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

Wystarczy użyć jawnego porównania z undefined.

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

Będąc wieloletnim programistą C++ (początkującym do tworzenia stron internetowych:)), kiedy po raz pierwszy natknąłem się na tę sytuację, zrobiłem przypisanie parametru w definicji funkcji, tak jak wspomniano w pytaniu, w następujący sposób.

function myfunc(a,b=10)

Ale uważaj, że nie działa konsekwentnie we wszystkich przeglądarkach. Dla mnie działał na chrome na moim pulpicie, ale nie działał na chrome na Androidzie. Bezpieczniejszą opcją, jak wielu wspomniało powyżej, jest -

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

Intencją tej odpowiedzi nie jest powtarzanie te same rozwiązania, o których inni już wspominali, ale informujemy, że przypisanie parametrów w definicji funkcji może działać na niektórych przeglądarkach, ale nie polegaj na tym.

Zalecam zachowanie szczególnej ostrożności przy używaniu domyślnych wartości parametrów w javascript. Często tworzy błędy, gdy są używane w połączeniu z funkcjami wyższego rzędu, takimi jak forEach, map, i reduce. Na przykład rozważ tę linię kodu:

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

ParseInt ma opcjonalny drugi parametr function parseInt(s, [radix=10]) ale map wywołuje parseInt z trzema argumentami: (element, index i array ).

Proponuję oddzielić wymagane parametry tworzą opcjonalne / domyślne wartości argumentów. Jeśli twoja funkcja przyjmuje 1,2 lub 3 wymagane parametry, dla których żadna wartość domyślna nie ma sensu, uczyń je parametrami pozycyjnymi do funkcji, wszelkie opcjonalne parametry powinny podążać za nazwanymi atrybutami pojedynczego obiektu. Jeśli twoja funkcja zajmuje 4 lub więcej, być może bardziej sensowne jest podawanie wszystkich argumentów za pomocą atrybutów jednego parametru obiektu.

W Twoim przypadku sugerowałbym napisanie funkcji deleteFile jak to:

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

Uruchomienie powyższego fragmentu ilustruje zagrożenia czyhające za domyślnymi wartościami argumentów dla nieużywanych parametrów.

Jako aktualizacja...za pomocą ECMAScript 6 Możesz wreszcie ustawić domyślne wartości w deklaracjach parametrów funkcji tak:

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

f(1) === 50

Jak wskazuje - http://es6-features.org/#DefaultParameterValues

Osobom zainteresowanym pracą kodu w Microsoft Edge nie należy używać wartości domyślnych w parametrach funkcji.

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

W tym przykładzie Edge wyrzuci błąd "Expecting') '"

Aby obejść to użycie

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

Zgodnie ze składnią

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

Można zdefiniować domyślną wartość parametrów formalnych. a także sprawdzić wartość niezdefiniowaną za pomocą funkcji 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!!!

ES6: Jak już wspomniano w większości odpowiedzi, w ES6 możesz po prostu zainicjalizować parametr wraz z wartością.

ES5: Większość udzielonych odpowiedzi nie jest dla mnie wystarczająco dobra, ponieważ są okazje, w których będę musiał przekazać fałszywe wartości, takie jak 0, null i undefined do funkcji. Aby określić, czy parametr jest niezdefiniowany, ponieważ jest to wartość, którą przekazałem zamiast undefined, ponieważ w ogóle nie został zdefiniowany, robię to:

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

Tutaj foo () jest funkcją, która ma parametr o nazwie argValue. Jeśli w wywołaniu funkcji nic nie przekażemy, wtedy zostanie wywołana funkcja throwIfNoValue () i zwrócony wynik zostanie przypisany do jedynego argumentu argValue. W ten sposób wywołanie funkcji może być użyte jako domyślny parametr. Co sprawia, że kod jest bardziej uproszczony i czytelny.

Ten przykład został zaczerpnięty stąd

Jeśli używasz ES6+ możesz ustawić domyślne parametry w następujący sposób:

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

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

Jeśli potrzebujesz ES5 składni możesz to zrobić w następujący sposób:

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

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

W powyższej składni używany jest operator OR. Operator OR zawsze zwraca pierwszą wartość, jeśli można ją przekonwertować na true, Jeśli nie zwraca wartość righthandside. Gdy funkcja jest wywoływana bez odpowiedniego argumentu zmienna parametru (bar w naszym przykładzie) jest ustawiona na undefined przez silnik JS. {[8] } jest następnie konwertowane na false i w ten sposób operator OR Zwraca wartość 0.

Użyj tego, jeśli chcesz użyć najnowszego ECMA6 składnia:

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

Nazywa się default function parameters. Pozwala na inicjalizację parametrów formalnych wartościami domyślnymi, jeśli nie zostanie przekazana żadna wartość lub undefined. Uwaga : nie będzie działać z Internet Explorerem lub starszymi przeglądarkami.

Dla maksymalnej możliwej kompatybilności Użyj tego:

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

Obie funkcje mają dokładnie takie samo zachowanie, jak każdy z tych przykładów polega na tym, że zmienna parametru będzie undefined, jeśli żadna wartość parametru nie została przekazana podczas wywoływania tej funkcji.

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

Następujący kod może działać w tej sytuacji, w tym ECMAScript 6 (ES6), jak również wcześniejsze wersje.

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

Jako wartość domyślna w językach działa, gdy wartość parametru funkcji jest pomijana podczas wywołania, w JavaScript jest przypisana do undefined . To podejście nie wygląda atrakcyjnie programowo, ale ma kompatybilność wsteczną .

Tak jest to określane jako domyślny parametr

Default function parameters allow formal parameters to be inicjalized with default values if no value or undefined is passed.

Składnia:

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

Opis:

Parametry funkcji domyślnie undefined jednak w sytuacjach może być przydatne ustawienie innej wartości domyślnej. Tutaj mogą pomóc domyślne parametry.

W przeszłości ogólna strategia ustawiania wartości domyślnych było testowanie wartości parametrów w ciele funkcji i przypisywanie wartości, jeśli są niezdefiniowane. Jeśli w wywołaniu nie zostanie podana żadna wartość, jej wartość będzie niezdefiniowana. Aby upewnić się, że parametr nie jest niezdefiniowany

Przy domyślnych parametrach w ES2015 sprawdzanie w ciele funkcji nie jest już konieczne. Teraz możesz po prostu umieścić domyślną wartość w głowicy funkcji.

Przykład różnic:

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

Inna Składnia Przykłady:

Padding undefined vs other falsy values:

Nawet jeśli wartość jest ustawiona jawnie podczas wywołania, wartość argumentu num jest wartością domyślną.

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)

Ocenione w czasie wywołania:

Domyślny argument jest oceniany podczas wywołania, więc w przeciwieństwie do innych języków, nowy obiekt jest tworzony za każdym razem, gdy funkcja jest wywoływana.

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

Domyślne parametry są dostępne dla późniejszych domyślnych parametrów:

Paramy już napotkane to dostępne dla późniejszych parametrów domyślnych

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

Funkcje zdefiniowane wewnątrz ciała funkcji:

Wprowadzony w Gecko 33 (Firefox 33 / Thunderbird 33 / SeaMonkey 2.30). Funkcje zadeklarowane w ciele funkcji nie mogą być odwołane do domyślnych parametrów i rzucać ReferenceError (obecnie TypeError w SpiderMonkey, patrz błąd 1022967). Domyślne parametry są zawsze wykonywane jako pierwsze, później obliczane są deklaracje funkcji wewnątrz ciała funkcji.

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

Parametry bez domyślnie po parametrach domyślnych:

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

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

Destrukcyjny parametr z domyślnym przypisaniem wartości:

Możesz użyć domyślnego przypisania wartości z zapis przypisania destrukcji

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

f(); // 6

Tak, to będzie działać w Javascript. Możesz też to zrobić:

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