我希望JavaScript函数具有可选的参数,我在这些参数上设置了默认值,如果未定义值,则使用这些参数(如果传递了值,则忽略这些参数)。在Ruby中,您可以这样做:

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

这在JavaScript中有效吗?

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

当前回答

作为更新。。。使用ECMAScript 6,您最终可以在函数参数声明中设置默认值,如下所示:

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

f(1) === 50

参考文件:http://es6-features.org/#DefaultParameterValues

其他回答

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

如果delete_after的值不是假值,则将其赋值给delete_aafter,否则将赋值字符串“我的默认值”。有关更多详细信息,请查看DougCrockford的语言调查,并查看操作员部分。

如果要传入假值,即false、null、undefined、0或“”,则此方法不起作用。如果需要传入假值,则需要使用Tom Ritter的答案中的方法。

当处理函数的多个参数时,允许使用者在对象中传递参数参数,然后将这些值与包含函数默认值的对象合并通常是有用的

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

如果您想使用最新的ECMA6语法,请使用此选项:

函数myFunction(someValue=“这是默认值!”){console.log(“someValue-->”,someValue);}myFunction(“不是默认值”)//调用没有默认值的函数myFunction()//使用默认值调用函数

它被称为默认函数参数。如果没有传递值或未定义,它允许使用默认值初始化形式参数。注意:它不适用于Internet Explorer或较旧的浏览器。

为了获得最大可能的兼容性,请使用以下选项:

函数myFunction(someValue){someValue=(someValue==未定义)?“这是默认值!”:someValue;console.log(“someValue-->”,someValue);}myFunction(“不是默认值”)//调用没有默认值的函数myFunction()//使用默认值调用函数

这两个函数具有完全相同的行为,因为这些示例依赖于这样一个事实:如果在调用该函数时没有传递任何参数值,则参数变量将是未定义的。

是的,这被称为默认参数

如果没有传递值或未定义,则默认函数参数允许使用默认值初始化形式参数。

语法:

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

不同语法示例:

填充未定义值与其他错误值:

即使在调用时显式设置了该值,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(当前SpiderMonkey中为TypeError,请参见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。这已经在bug 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

函数throwIfNoValue(){抛出新错误(“缺少参数”);}函数foo(argValue=throwIfNoValue()){返回argValue;}

这里foo()是一个函数,它有一个名为argValue的参数。如果我们在这里的函数调用中没有传递任何信息,那么将调用throwIfNoValue()函数,并将返回的结果分配给唯一的参数argValue。这就是函数调用可以用作默认参数的方式。这使得代码更加简化和可读。

此示例取自此处

默认参数值

使用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是假的,所以x||11的结果是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!==未定义?x:11比更常见的成语x||11

默认值表达式

函数默认值可以不仅仅是像31这样的简单值;它们可以是任何有效的表达式,甚至是函数调用:

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