JavaScript中有更好的可选函数参数的方式吗？

大家好 -

在查看这些和其他解决方案后，我尝试了一些以W3Schools为基础的代码片段。您可以在以下找到有效的内容。每个被注释掉的项目也同样有效，并且这样做是为了让您通过删除单个注释来进行实验。明确地说，未定义“eyecolor”参数。

function person(firstname, lastname, age, eyecolor)
{
this.firstname = firstname;
this.lastname = lastname;
this.age = age;
this.eyecolor = eyecolor;
// if(null==eyecolor)
//   this.eyecolor = "unknown1";
//if(typeof(eyecolor)==='undefined') 
//   this.eyecolor = "unknown2";
// if(!eyecolor)
//   this.eyecolor = "unknown3";
this.eyecolor = this.eyecolor || "unknown4";
}

var myFather = new person("John", "Doe", 60);
var myMother = new person("Sally", "Rally", 48, "green");

var elem = document.getElementById("demo");
elem.innerHTML = "My father " +
              myFather.firstname + " " +
              myFather.lastname + " is " +
              myFather.age + " with " +
              myFather.eyecolor + " eyes.<br/>" +
              "My mother " +
              myMother.firstname + " " +
              myMother.lastname + " is " +
              myMother.age + " with " +
              myMother.eyecolor + " eyes."; 

function WhoLikesCake(options) {
  options = options || {};
  var defaultOptions = {
    a : options.a || "Huh?",
    b : options.b || "I don't like cake."
  }
  console.log('a: ' + defaultOptions.b + ' - b: ' + defaultOptions.b);

  // Do more stuff here ...
}

被这样调用：

WhoLikesCake({ b : "I do" });

function Default(variable, new_value)
{
    if(new_value === undefined) { return (variable === undefined) ? null : variable; }
    return (variable === undefined) ? new_value : variable;
}

var a = 2, b = "hello", c = true, d;

var test = Default(a, 0),
test2 = Default(b, "Hi"),
test3 = Default(c, false),
test4 = Default(d, "Hello world");

window.alert(test + "\n" + test2 + "\n" + test3 + "\n" + test4);

http://jsfiddle.net/mq60hqrf/

看起来最安全的方法 - 在决定使用默认值之前，处理所有\任何提供的虚假类型的参数 - 是检查调用函数中可选参数的存在\出现。

依赖于参数对象成员创建，如果缺少参数，则不会创建该成员，而不管它是否声明，我们可以像这样编写您的函数：

  function myFunc(requiredArg, optionalArg){
        optionalArg = 1 in arguments ? optionalArg : 'defaultValue';
  //do stuff
  }

function argCheck( arg1, arg2, arg3 ){

       arg1 = 0 in arguments || undefined;
       arg2 = 1 in arguments || false;
       arg3 = 2 in arguments || 0;
   var arg4 = 3 in arguments || null;

   console.log( arg1, arg2, arg3, arg4 ) 
}

现在，检查几个假值参数的存在是否被正确检测并因此评估为true：

argCheck( "", 0, false, null );
>> true true true true

argCheck( );
>> undefined false 0 null

正如我们所看到的，参数arg1、arg2、arg3和未声明的arg4都按照顺序返回它们的确切默认值。因为我们现在已经确保它可以工作，我们可以重写函数，实际上能够像第一个示例那样使用它们，方法是使用：if或三元条件。

对于具有多个可选参数的函数，-循环可能会节省一些位。但由于如果没有提供值，参数名称不会被初始化，因此我们无法再通过名称访问它们，即使我们已经以编程方式编写了默认值，我们只能通过arguments[index]访问它们，这在代码可读性方面是无用的。

但除了这种不便之外，在某些编码情况下可能完全可以接受，还存在另一个未经考虑的问题，即多个和任意数量的参数默认值。这可能并且应该被视为错误，因为我们不能再跳过参数，就像我们曾经能够做的那样，在语法中不给出值，例如：

argCheck("a",,22,{});

因为它会抛出异常！这使我们无法使用特定的 falsy 类型来替换我们所需的默认值参数。

这很愚蠢，因为arguments object是一个类似数组的对象，并且期望本地或默认支持此语法和约定！

由于这个短视的决定，我们再也无法编写像这样的函数：

function argCheck( ) {
    var _default = [undefined, 0, false, null ],
        _arg = arguments;

 for( var x in _default ) {
         x in _arg ? 1 : _arg[x] = _default[x];
        }
    console.log( _arg[0],_arg[1],_arg[2],_arg[3] );
}

在这种情况下，我们将能够在参数行中编写所需类型的每个默认值，并且至少能够通过args.index访问它们。

例如，此函数调用将产生以下结果：

argCheck();
>>undefined 0 false null

如在我们默认的参数数组值中定义。 然而以下仍然是可能的：

argCheck({})
>>Object {  } 0 false null

argCheck({}, [])
>>Object {  } Array [  ] false null

但遗憾的是：

 argCheck("a",,,22);
 >>SyntaxError: expected expression, got ','

否则将记录日志：

>>a 0 false 22

但那只存在于一个更美好的世界！ 然而 - 对于原始问题 - 最上层的函数就可以了。 例如：

function argCheck( arg, opt ) {
         1 in arguments ? 1 : opt = "default";
         console.log( arg, opt );
}

p.s.：抱歉在编写参数输入时没有保留所选默认值的类型。

这些比 typeof 运算符版本更短。

function foo(a, b) {
    a !== undefined || (a = 'defaultA');
    if(b === undefined) b = 'defaultB';
    ...
}

如果我错了，请纠正我，但这似乎是最简单的方法（至少对于一个参数）：

function myFunction(Required,Optional)
{
    if (arguments.length<2) Optional = "Default";
    //Your code
}

我建议您这样使用ArgueJS：

function myFunc(){
  arguments = __({requiredArg: undefined, optionalArg: [undefined: 'defaultValue'})

  //do stuff, using arguments.requiredArg and arguments.optionalArg
  //    to access your arguments

}

您还可以将 undefined 替换为您期望接收的参数类型，例如：

function myFunc(){
  arguments = __({requiredArg: Number, optionalArg: [String: 'defaultValue'})

  //do stuff, using arguments.requiredArg and arguments.optionalArg
  //    to access your arguments

}

function foo(requiredArg){
  if(arguments.length>1) var optionalArg = arguments[1];
}