Я хотел бы, чтобы функция JavaScript имела необязательные аргументы, для которых я установил значение по умолчанию, которые используются, если значение не определено (и игнорируется, если значение передается). В Ruby вы можете сделать это так:
def read_file(file, delete_after = false)
# code
end
Это работает в JavaScript?
function read_file(file, delete_after = false) {
// Code
}
Начиная с 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';
...
}
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" });
Я нахожу что-то простое, как это, гораздо более сжатым и читаемым лично.
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, если оно отсутствует или undefined. Вы можете использовать такие функции ES6, как сегодня, с транспилерами, такими как Babel.
Значения параметров по умолчанию
С 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
это решение работает для меня в 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; }
}
В качестве обновления... с ECMAScript 6 вы можете ПОЛНОСТЬЮ установить значения по умолчанию в объявлениях параметров функции следующим образом:
function f (x, y = 7, z = 42) {
return x + y + z
}
f(1) === 50
Как упоминалось - http://es6-features.org/#DefaultParameterValues
являющийся разработчиком С++ долгое время (Rookie to web development:)), когда я впервые столкнулся с этой ситуацией, я сделал назначение параметров в определении функции, как это указано в вопросе, следующим образом.
function myfunc(a,b=10)
Но будьте осторожны, что он не работает последовательно в браузерах. Для меня это работало на хроме на моем рабочем столе, но не работало на хроме на 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, [ второго параметра 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);Для всех, кто заинтересован в работе с кодом в 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 года это все еще проблема
В соответствии с синтаксисом
function [name]([param1[ = defaultValue1 ][, ..., paramN[ = defaultValueN ]]]) {
statements
}
вы можете определить значение по умолчанию для формальных параметров. а также проверить значение undefined с помощью функции 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!!!
Используйте это, если вы хотите использовать последний синтаксис 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 valueES6: Как уже упоминалось в большинстве ответов, в ES6 вы можете просто инициализировать параметр вместе со значением.
ES5: Большинство из приведенных ответов недостаточно для меня, потому что есть случаи, когда мне, возможно, придется передавать ложные значения, такие как 0, null и 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 ;
} Если вы используете ES6+ вы можете установить параметры по умолчанию следующим образом:
function test (foo = 1, bar = 2) {
console.log(foo, bar);
}
test(5); // foo gets overwritten, bar remains default parameter Если по каким - то причинам вы не на 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>Да, использование параметров по умолчанию полностью поддерживается в 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 будет заменено, если только переданное значение верно, потому что путь || за работой...
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');Да, это называется параметром по умолчанию
Параметры функции по умолчанию позволяют инициализировать формальные параметры со значениями по умолчанию, если значение не определено или не определено.
Синтаксис:
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
Просто другой подход для установки параметров по умолчанию состоит в том, чтобы использовать объектную карту аргументов, а не аргументы напрямую. Например,
const defaultConfig = {
category: 'Animals',
legs: 4
};
function checkOrganism(props) {
const category = props.category || defaultConfig.category;
const legs = props.legs || defaultConfig.legs;
}
Таким образом, можно легко расширять аргументы и не беспокоиться о несоответствии длины аргументов.
В будущем вы сможете "распространять" один объект на другой (в настоящее время по состоянию на 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'});Ответ - да. На самом деле, есть много языков, которые поддерживают параметры по умолчанию. Python является одним из них:
def(a, enter="Hello"):
print(a+enter)
Хотя это код Python 3 из-за круглых скобок, параметры по умолчанию в функциях также работают в JS.
Например, и в вашем случае:
function read_file(file, deleteAfter=false){
console.log(deleteAfter);
}
read_file("test.txt");Да, это будет работать в 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