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

Ответ 1

Начиная с 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';
  ...
}

Ответ 2

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

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

Этот подход не работает, если вы хотите передать значение false, т.е. 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" }); 

Ответ 3

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

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

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

Ответ 4

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

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

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

Подробнее см. статью MDN.

Ответ 5

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

С 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; они могут быть любым допустимым выражением, даже a 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

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

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

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

Ответ 6

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

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

Ответ 7

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

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

Ответ 8

В качестве обновления... с ECMAScript 6 вы можете ПОЛНОСТЬЮ установить значения по умолчанию в объявлениях параметров функции следующим образом:

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

f(1) === 50

Как упоминалось - http://es6-features.org/#DefaultParameterValues

Ответ 9

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

function myfunc(a,b=10)

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

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

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

Ответ 10

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

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

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

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

В вашем случае я бы предложил вам написать функцию deleteFile следующим образом: (отредактировано instead комментариев)...

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

Ответ 11

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

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

В этом примере Edge выдаст ошибку "Ожидание" ) "

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

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

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

Ответ 12

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

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

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

Ответ 13

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

Ответ 14

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

Ответ 15

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

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

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

Ответ 16

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

Ответ 17

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

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

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

Ответ 18

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

Ответ 19

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

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 одно, даже если оно будет ложным, которое будет заменено новым значением, например, null или ""... но только одно ES5 будет заменено, если только переданное значение верно, потому что путь || за работой...

Ответ 20

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

Ответ 21

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

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

Синтаксис:

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

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

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

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, см. Ошибку 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]

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

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

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

f(); // 6

Ответ 22

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

const defaultConfig = {
 category: 'Animals',
 legs: 4
};

function checkOrganism(props) {
 const category = props.category || defaultConfig.category;
 const legs = props.legs || defaultConfig.legs;
}

Таким образом, можно легко расширять аргументы и не беспокоиться о несоответствии длины аргументов.

Ответ 23

Звуки будущего

В будущем вы сможете "распространять" один объект на другой (в настоящее время по состоянию на 2019 г. НЕ поддерживается Edge!) - демонстрация того, как использовать это для хороших параметров по умолчанию независимо от порядка:

function test(options) {
    var options = {
       // defaults
       url: 'defaultURL',
       some: 'somethingDefault',
       // override with input options
       ...options
    };
    
    var body = document.getElementsByTagName('body')[0];
    body.innerHTML += '<br>' + options.url + ' : ' + options.some;
}
test();
test({});
test({url:'myURL'});
test({some:'somethingOfMine'});
test({url:'overrideURL', some:'andSomething'});
test({url:'overrideURL', some:'andSomething', extra:'noProblem'});

Ответ 24

Ответ - да. На самом деле, есть много языков, которые поддерживают параметры по умолчанию. Python является одним из них:

def(a, enter="Hello"):
   print(a+enter)

Хотя это код Python 3 из-за круглых скобок, параметры по умолчанию в функциях также работают в JS.

Например, и в вашем случае:

function read_file(file, deleteAfter=false){
  console.log(deleteAfter);
}

read_file("test.txt");

Ответ 25

Да, это будет работать в 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