Установить значение параметра по умолчанию для функции JavaScript.

javascript function parameters default-parameters


Я бы хотел,чтобы функция JavaScript имела необязательные аргументы,которые я устанавливаю по умолчанию,которые будут использоваться,если значение не определено (и игнорироваться,если значение передано).В Ruby это можно сделать вот так:

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

Работает ли это на JavaScript?

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



Answer 1 Tom Ritter


Начиная с ES6 / ES2015 , параметры по умолчанию находятся в спецификации языка.

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

просто работает.

Ссылка: Параметры по умолчанию - MDN

Параметры функции по умолчанию позволяют формальным параметрам инициализироваться значениями по умолчанию, если не передано значение или неопределенное значение .

Вы также можете смоделировать именованные параметры по умолчанию с помощью деструктурирования :

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

До ES2015 ,

Есть много способов, но это мой предпочтительный метод - он позволяет вам передавать все, что вы хотите, включая false или null. ( typeof null == "object" )

function foo(a, b) {
  a = typeof a !== 'undefined' ? a : 42;
  b = typeof b !== 'undefined' ? b : 'default_b';
  ...
}



Answer 2 Russ Cam


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

Это присваивает delete_after значение delete_after , если оно не является ложным значением, в противном случае оно присваивает строку "my default here" . Для более подробной информации, ознакомьтесь с обзором языка Дуга Крокфорда и ознакомьтесь с разделом «Операторы» .

Такой подход не работает , если вы хотите передать в falsey то есть значение false , null , undefined , 0 или "" . Если вам требуется, чтобы значения false были переданы, вам нужно будет использовать метод в ответе Тома Риттера .

При работе с рядом параметров функции часто бывает полезно разрешить потребителю передавать аргументы параметра в объекте, а затем объединять эти значения с объектом, который содержит значения по умолчанию для функции.

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

для использования

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



Answer 3 TJ L


Я нахожу что-то простое,чтобы быть намного более лаконичным и читабельным лично для меня.

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

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



Answer 4 Felix Kling


В ECMAScript 6 вы действительно сможете написать именно то,что у вас есть:

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

Это установит delete_after в false , если он отсутствует или undefined . Подобные функции ES6 вы можете использовать сегодня с такими транспортерами, как Babel .

См. Статью MDN для получения дополнительной информации .




Answer 5 Thalaivar


Значения параметров по умолчанию

С ES6 вы можете сделать, пожалуй, одну из наиболее распространенных идиом в JavaScript , связанных с установкой значения по умолчанию для параметра функции. То, как мы делали это годами, должно выглядеть довольно знакомо:

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

Этот паттерн наиболее часто используется,но он опасен,когда мы передаем значения вроде

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

Зачем? Потому что 0 is falsy , и поэтому x || 11 results in 11 , а не к непосредственному переданному 0. Чтобы исправить эту ошибку, некоторые люди вместо этого напишут чек более подробно так:

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

Теперь мы можем изучить хороший полезный синтаксис, добавленный в ES6 , чтобы упростить назначение значений по умолчанию отсутствующим аргументам:

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 в объявлении функции больше похоже на x !== undefined ? x : 11 чем гораздо более распространенная идиома x || 11

Выражения значений по умолчанию

Function Значения по умолчанию для функции могут быть не просто простыми значениями, такими как 31; они могут быть любым допустимым выражением, даже 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

Как видите, выражения значений по умолчанию лениво оцениваются, то есть они запускаются только тогда и только тогда, когда они необходимы, то есть, когда аргумент параметра опущен или не определен.

Выражением значения по умолчанию может быть даже вызов встроенного выражения функции, обычно называемый выражением немедленного вызова функции (IIFE) :

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