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

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

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

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

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

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 to false если его нет или undefined. Вы можете использовать функции ES6, такие как этот, сегодня с транспиляторами, такими как Бабель.

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

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

с 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

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

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

просто используйте явное сравнение с undefined.

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

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

function myfunc(a,b=10)

но будьте осторожны, что он не работает последовательно в браузерах. Для меня он работал на chrome на моем рабочем столе, но не работал на chrome на android. Более безопасный вариант, как многие уже упоминали выше -

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

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

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

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

parseInt имеет необязательный второй параметр function parseInt(s, [основание=10]) а карте звонков parseInt С тремя аргументами: (элемент, индекс, и массив).

Я предлагаю вам отделить требуемые параметры от необязательных / значений по умолчанию. Если ваша функция принимает 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 = 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);

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

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

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

f(1) === 50

как указано в - http://es6-features.org/#DefaultParameterValues

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

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

в этом примере Edge выдаст ошибку " Expecting ')'"

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

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

по состоянию на 08 августа 2016 года это все еще проблема

согласно синтаксис

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

можно определить значение по умолчанию для формальных параметров. а также проверьте неопределенное значение с помощью 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!!!

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

в ES5: большинство данных ответов недостаточно хороши для меня, потому что есть случаи, когда мне, возможно, придется передать ложные значения, такие как 0, null и undefined функции. Чтобы определить, является ли параметр неопределенным, потому что это значение, которое я передал вместо undefined из-за того, что не было определено вообще, я делаю это:

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

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

этот пример взят отсюда

если вы используете 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

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

используйте это, если вы хотите использовать последнюю 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

Это называется default function 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 если при вызове этой функции не было передано значение параметра.

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

в этой ситуации может работать следующий код, включая ECMAScript 6 (ES6), а также более ранние версии.

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

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

Да, это называется параметром по умолчанию

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

синтаксис:

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

описание:

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

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

с параметрами по умолчанию в 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

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

заполнение undefined против других ложных значений:

даже если значение задано явно при вызове, значение аргумента 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

параметры по умолчанию доступны для более поздних параметров по умолчанию:

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

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 / Thunderbird 33 / SeaMonkey 2.30). Функции, объявленные в теле функции, нельзя ссылаться внутри параметров по умолчанию и вызывать ReferenceError (в настоящее время TypeError в SpiderMonkey, см. bug 1022967). Параметры по умолчанию всегда выполняются сначала, объявления функций внутри тела функции оцениваются впоследствии.

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

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

до Gecko 26 (Firefox 26 / Thunderbird 26 / SeaMonkey 2.23 / Firefox OS 1.2) следующий код привел к SyntaxError. Это было исправлено в баг 777060 и работает, как ожидалось в более поздних версиях. Параметры по-прежнему слева направо, перезапись параметров по умолчанию даже если есть более поздние параметры без значений по умолчанию.

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

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

разрушенный paramet с присвоением значения по умолчанию:

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

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

f(); // 6

Да, это будет работать в Javascript. Вы также можете сделать это:

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