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

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

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

Это работает в JavaScript?

function read_file(file, delete_after = false) {
  // Code
}
+2256
источник поделиться
25 ответов

Начиная с 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';
  ...
}
+3193
источник
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" }); 
+590
источник
другие ответы

Связанные вопросы


Похожие вопросы

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

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

function myFunc(x) {
  x = pick(x, 'my default');
} 
+144
источник

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

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

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

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

+62
источник

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

С 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
+26
источник

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

function read_file(file, delete_after) {
    delete_after = delete_after || false;
    // Code
}
+11
источник

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

function read_file(file, delete_after)
{
    if(delete_after === undefined) { delete_after = false; }
}
+9
источник

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

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

f(1) === 50

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

+8
источник

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

function myfunc(a,b=10)

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

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

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

+7
источник

Я очень рекомендую предельную осторожность при использовании значений параметров по умолчанию в 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);

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

+7
источник

Для всех, кто заинтересован в работе с кодом в 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 года это все еще проблема

+6
источник

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

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

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

+3
источник
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!!!
+3
источник

Используйте это, если вы хотите использовать последний синтаксис 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. Он позволяет инициализировать формальные параметры со значениями по умолчанию, если не передано значение или неопределенный. ПРИМЕЧАНИЕ. Он не будет работать с 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 если при вызове этой функции не было передано значение параметра.

+3
источник

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


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

function foo (param1, param2) {
   param1 = arguments.length >= 1 ? param1 : "default1";
   param2 = arguments.length >= 2 ? param2 : "default2";
}
+3
источник

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

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

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

+2
источник

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

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

+2
источник

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

Который установит значение по умолчанию, если текущее значение равно NaN, null или undefined

+1
источник

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

+1
источник
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 ему присваивается неопределенное значение. Этот подход не выглядит привлекательно программно, но имеет обратную совместимость.

0
источник

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

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

Синтаксис:

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
0
источник

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

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

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

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

0
источник

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

В будущем вы сможете "распространять" один объект на другой (в настоящее время по состоянию на 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'});

Ссылка на MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax

... между тем, Edge DOES поддерживает Object.assign() (IE нет, но я действительно надеюсь, что мы можем оставить IE позади :))

Точно так же вы могли бы сделать

    function test(options) {
        var options = Object.assign({
           // defaults
           url: 'defaultURL',
           some: 'somethingDefault',
        }, options); // override with input 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'});

0
источник

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

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

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

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

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

read_file("test.txt");

Но иногда вам не нужны параметры по умолчанию.

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

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

read_file("test.txt");

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

Итак, в заключение, значения параметров по умолчанию могут быть использованы в JS. Но это почти то же самое, что определение переменной сразу после запуска функции. Однако иногда они все еще очень полезны. Как вы могли заметить, значения параметров по умолчанию занимают на 1 строку кода меньше стандартного способа, который определяет параметр сразу после запуска функции.

ОБНОВЛЕНИЕ: И это очень важно! Это не будет работать в IE. Смотрите документацию. Так что с IE вы должны использовать метод "определить переменную в верхней части функции". Параметры по умолчанию не будут работать в IE.

-1
источник

Да, это будет работать в 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
-3
источник

Посмотрите другие вопросы по меткам или Задайте вопрос