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

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

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

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

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

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

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

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

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

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
}

Это присваивает delete_after значение delete_after, если оно не является фальшивым значением, в противном случае присваивается строка `"мое значение по умолчанию здесь". Для получения более подробной информации ознакомьтесь с обзором языка, сделанным Дагом Крокфордом (Doug Crockford'), и посмотрите раздел, посвященный операторам.

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

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

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

Лично я считаю, что такие простые вещи гораздо более лаконичны и читабельны.

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

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

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

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

Это позволит установить delete_after на false, если он не присутствует или "неопределенным". Вы можете использовать возможности ES6 сегодня такой один с transpilers, такие как Бабель.

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

Значения Параметров По Умолчанию

С ЕС6, вы можете сделать, пожалуй, один из самых распространенных идиом в 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 

это решение работает для меня в JS:

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

Просто использовать явное сравнение с неопределено.

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

Как обновление...с ECMAScript 6 Вы можете наконец установить значения по умолчанию в объявлении параметра функции вот так:

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

f(1) === 50

А ссылка - http://es6-features.org/#DefaultParameterValues

Я очень рекомендую крайнюю осторожность при использовании значений параметров по умолчанию в JavaScript. Это часто создает ошибки при использовании в сочетании с функциями высшего порядка, как объекту, map и уменьшить. Например, рассмотрим следующую строку кода:

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

parseInt имеет функцию parseInt необязательный второй параметр(с [**основание**=10])`, но parseInt карте звонков с тремя аргументами: (element, index, и array).

Я предлагаю вам отделить необходимые параметры формы ваше опционного/по умолчанию ценятся аргументы. Если ваша функция принимает 1,2, или 3 необходимых параметров, для которых значение по умолчанию не имеет смысла, сделать их позиционные параметры, функции, дополнительные параметры должны следовать в виде именованных атрибутами одного объекта. Если ваша функция принимает 4 или более, может быть, разумнее поставить все аргументы через атрибуты одного параметра объекта.

В вашем случае я хотел бы предложить вам написать свой функция deletefile такой: (отредактировано в вместо'ы комментарии)...

в

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

в

Запустив приведенный выше фрагмент иллюстрирует опасностей, таящихся за значения аргументов по умолчанию для неиспользуемых параметров.

будучи долгое время разработчик C++ (Новичок в веб-разработке :)), когда я впервые наткнулся на эту ситуацию, я сделал задание параметра в определении функции, как это упомянуто в вопросе, как следует.

function myfunc(a,b=10)

Но будьте осторожны, что он не'т работать стабильно в разных браузерах. Для меня это работает в Chrome на моем рабочем столе, но не работает в Chrome на Android. Безопасным вариантом, так как многие уже упоминали выше -

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

Намерение для этого ответа не повторять одни и те же решения, что другие уже упомянули, но, чтобы сообщить, что задание параметра в определении функции может работать на некоторых браузерах, но Дон'т полагаться на него.

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

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

В этом примере краю бросит ошибке "ожидая ')'&и"

Чтобы обойти это использовать

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

По состоянию на 08 августа 2016 это еще вопрос

В соответствии с синтаксисом

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

вы можете определить значение по умолчанию для формального параметра. а также проверьте значение undefined с помощью для вызова typeof функция.

ЕС6: как уже говорилось в большинстве ответов, в ЕС6, вы можете просто инициализировать параметр со значением.

В ES5: большинство даны ответы арен'т достаточно хорошо для меня, потому что бывают случаи, когда мне, вероятно, придется пройти falsey значения, такие как 0, нуль и неопределенные функции. Чтобы определить, если параметр не определен, так что's значение, я прошел вместо неопределенной причине не были определены вообще я делаю так:

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

Используйте это, если вы хотите использовать последний ECMA6 синтаксис:

в

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

в

Это называется parameters функция по умолчанию. Это позволяет формальные параметры должны быть инициализированы значениями по умолчанию, если никакое значение или undefined передается. Примечание: это не будет работать с Internet Explorer или старых браузерах.

Для максимально возможного совместимость использовать это:

в

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

в

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

Да, используя параметры по умолчанию полностью поддерживается ЕС6:

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

или

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

но до В в ES5 вы можете легко сделать это:

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

Что означает, если значение есть, использовать значение, в противном случае, используйте второе значение после операции | | который делает то же самое...

Примечание: также есть большая разница между тем, если вы передаете значение на ES6 еще одно значение ложь, которое будет заменено на новое значение, что-то вроде нуль, или в "" В... но в ES5 один только замене только, если переданное значение-истина, что's, потому что путь || рабочая...

Если вы используете на ES6+ можно задать параметры по умолчанию следующим образом:

в

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

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

в

Если вы нуждаетесь в ES5 синтаксис вы можете сделать это следующим образом:

в

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

  console.log(foo, bar);
}

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

в

В приведенном выше синтаксисе используется или оператор. В или оператор всегда возвращает первое значение, если это может быть преобразовано в true, если не возвращает righthandside значение. Когда функция вызывается без соответствующего аргумента параметр переменной (бар в нашем примере) получит значение undefined в JS движок. неопределенное потом конвертируется в false и таким образом " или " оператор вернет значение 0.

в

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

в

Здесь функция Foo () - это функция, которая имеет параметр с именем argValue. Если мы ничего не передаем здесь называю функцию, то throwIfNoValue функция() будет называться и возвращенный результат будет назначена только argValue аргумент. Это как вызов функции может использоваться в качестве параметра по умолчанию. Что делает код более простым и читаемым.

Этот пример был взят из здесь

Если по каким-то причинам вы не на ES6 и **** и используя лодашь здесь-это краткий путь к дефолту параметры функции через _.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>

в

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

Да это упоминается как параметр по умолчанию

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

Синтаксис:

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

Описание:

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

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

С параметрами по умолчанию в ES2015, проверка в теле функции больше нет необходимости. Теперь вы можете просто поставить значение по умолчанию в функции головы.

Пример различий:

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

Различные Примеры Синтаксис:

Обивка не определено против других значений ложь:

Даже если значение явно не задано при вызове, значение аргумента num-это по умолчанию.

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)

Вычислено во время вызова:

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

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

Параметры по умолчанию доступен для позже параметрами по умолчанию:

Params уже сталкивался доступны для позже параметрами по умолчанию

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

Функции, определенные в теле функции:

Введен в Gecko 33 (Firefox 33 с / Тандерберд 33 / был SeaMonkey 2.30). Функции, объявленные в теле функции не могут быть отнесены внутри параметров по умолчанию и бросить ReferenceError (в настоящее время ошибку TypeError в SpiderMonkey, см. ошибку 1022967). Параметры по умолчанию всегда выполняется первой, объявления функции внутри тела функции после оценки.

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

Параметры без значений по умолчанию после того, как параметры по умолчанию:

До Гекко 26 (В Firefox 26 / Тандерберд 26 / 2.23 не Opera / Firefox ОС 1.2), следующий код в результате синтаксис ошибка. Это было исправлено в баг 777060 и работает, как ожидалось в более поздних версиях. Параметры по-прежнему слева направо, перезапись параметров по умолчанию, даже если впоследствии параметров без значений по умолчанию.

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

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

Деструктурированных п АР Амет р с присвоения значений по умолчанию:

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

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

f(); // 6