有没有更好的方法来在 JavaScript 中做可选的函数参数？[复制]

如果传递了 optionalArg，则逻辑失败，但计算结果为 false - 尝试这样做作为替代方法

if (typeof optionalArg === 'undefined') { optionalArg = 'default'; }

或者另一种成语：

optionalArg = (typeof optionalArg === 'undefined') ? 'default' : optionalArg;

使用最能传达您意图的成语！

为此，您可以使用一些不同的方案。我一直在测试arguments.length：

function myFunc(requiredArg, optionalArg){
  optionalArg = myFunc.arguments.length<2 ? 'defaultValue' : optionalArg;

  ...

——这样做，它不可能失败，但我不知道你的方式是否有失败的机会，只是现在我想不出一个场景，它实际上会失败......

然后保罗提供了一个失败的场景！

如果你需要插入一个文字，那么你可能会遇到一些问题。除此之外，不，我认为你可能走在正确的轨道上。NULL

有些人选择的另一种方法是采用变量的关联数组遍历参数列表。它看起来有点整洁，但我想它有点（很少）更多的进程/内存密集型。

function myFunction (argArray) {
    var defaults = {
        'arg1'  :   "value 1",
        'arg2'  :   "value 2",
        'arg3'  :   "value 3",
        'arg4'  :   "value 4"
    }

    for(var i in defaults) 
        if(typeof argArray[i] == "undefined") 
               argArray[i] = defaults[i];

    // ...
}

与 Oli 的回答类似，我使用了一个参数 Object 和一个定义默认值的 Object。加一点糖...

/**
 * Updates an object's properties with other objects' properties. All
 * additional non-falsy arguments will have their properties copied to the
 * destination object, in the order given.
 */
function extend(dest) {
  for (var i = 1, l = arguments.length; i < l; i++) {
    var src = arguments[i]
    if (!src) {
      continue
    }
    for (var property in src) {
      if (src.hasOwnProperty(property)) {
        dest[property] = src[property]
      }
    }
  }
  return dest
}

/**
 * Inherit another function's prototype without invoking the function.
 */
function inherits(child, parent) {
  var F = function() {}
  F.prototype = parent.prototype
  child.prototype = new F()
  child.prototype.constructor = child
  return child
}

...这可以做得更好一点。

function Field(kwargs) {
  kwargs = extend({
    required: true, widget: null, label: null, initial: null,
    helpText: null, errorMessages: null
  }, kwargs)
  this.required = kwargs.required
  this.label = kwargs.label
  this.initial = kwargs.initial
  // ...and so on...
}

function CharField(kwargs) {
  kwargs = extend({
    maxLength: null, minLength: null
  }, kwargs)
  this.maxLength = kwargs.maxLength
  this.minLength = kwargs.minLength
  Field.call(this, kwargs)
}
inherits(CharField, Field)

这种方法有什么好处？

• 您可以省略任意数量的参数 - 如果您只想覆盖一个参数的值，则只需提供该参数，而不必显式传递，例如有 5 个参数并且您只想自定义最后一个参数，就像您必须使用建议的其他一些方法一样。undefined
• 当使用从另一个对象继承的构造函数时，很容易接受你所继承的对象的构造函数所需的任何参数，因为你不必在构造函数签名中命名这些参数，甚至不必提供你自己的默认值（让父对象的构造函数为你做这件事， 如上所述，当调用 的构造函数时）。CharFieldField
• 继承层次结构中的子对象可以根据需要自定义其父构造函数的参数，强制执行自己的默认值或确保始终使用某个值。

我发现这是最简单、最易读的方式：

if (typeof myVariable === 'undefined') { myVariable = 'default'; }
//use myVariable here

保罗·迪克森（Paul Dixon）的回答（以我的拙见）的可读性不如这个，但归根结底是偏好。

Insin的答案要先进得多，但对于大型函数更有用！

编辑 2013/11/17 9：33pm：我为 Node.js 创建了一个包，可以更轻松地“重载”称为参数化的函数（方法）。

理想情况下，您可以重构以传递一个对象并将其与默认对象合并，因此传递参数的顺序无关紧要（请参阅下面本答案的第二部分）。

但是，如果您只想要快速、可靠、易于使用且体积不大的东西，请尝试以下方法：

---

对任意数量的默认参数进行干净的快速修复

• 它可以优雅地扩展：每个新的默认值只需最少的额外代码
• 您可以将其粘贴到任何位置：只需更改所需的参数和变量的数量即可
• 如果要传递给具有默认值的参数，则该变量将设置为 。此页上的大多数其他选项将替换为默认值。undefinedundefinedundefined

下面是一个示例，用于为三个可选参数（包含两个必需参数）提供默认值

function myFunc( requiredA, requiredB,  optionalA, optionalB, optionalC ) {

  switch (arguments.length - 2) { // 2 is the number of required arguments
    case 0:  optionalA = 'Some default';
    case 1:  optionalB = 'Another default';
    case 2:  optionalC = 'Some other default';
    // no breaks between cases: each case implies the next cases are also needed
  }

}

简单的演示。这类似于 roenving 的答案，但可以很容易地扩展到任意数量的默认参数，更易于更新，并且使用参数而不是 Function.arguments。

---

传递和合并对象以提高灵活性

上面的代码，就像许多做默认参数的方法一样，不能不按顺序传递参数，例如，传递但离开以回退到其默认值。optionalCoptionalB

一个不错的选择是传递对象并与默认对象合并。这也有利于可维护性（只要注意保持代码的可读性，这样未来的协作者就不会猜测你传递的对象的可能内容）。

使用 jQuery 的示例。如果您不使用 jQuery，则可以改用 Underscore 或浏览以下选项：_.defaults(object, defaults)

function myFunc( args ) {
  var defaults = {
    optionalA: 'Some default',
    optionalB: 'Another default',
    optionalC: 'Some other default'
  };
  args = $.extend({}, defaults, args);
}

这是一个简单的实际示例。

如果您广泛使用默认值，这似乎更具可读性：

function usageExemple(a,b,c,d){
    //defaults
    a=defaultValue(a,1);
    b=defaultValue(b,2);
    c=defaultValue(c,4);
    d=defaultValue(d,8);

    var x = a+b+c+d;
    return x;
}

只需在全局 escope 上声明此函数即可。

function defaultValue(variable,defaultValue){
    return(typeof variable!=='undefined')?(variable):(defaultValue);
}

使用模式fruit = defaultValue(fruit,'Apple');

*PS 您可以将函数重命名为短名称，只是不要在 javascript 中使用它是保留字。defaultValuedefault

在 ECMAScript 2015（又名“ES6”）中，您可以在函数声明中声明默认参数值：

function myFunc(requiredArg, optionalArg = 'defaultValue') {
    // do stuff
}

有关它们的更多信息，请参阅这篇关于 MDN 的文章。

目前只有 Firefox 支持此功能，但随着标准的完成，预计支持将迅速提高。

---

编辑 （2019-06-12）：

现代浏览器现在广泛支持默认参数。
所有版本的 Internet Explorer 都不支持此功能。但是，Chrome、Firefox 和 Edge 目前支持它。

如果我错了，请纠正我，但这似乎是最简单的方法（无论如何，对于一个论点）：

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

}

我不知道为什么@Paul的回复被否决了，但反对的验证是一个不错的选择。也许一个更肯定的例子会更有意义：null

在 JavaScript 中，丢失的参数就像一个未初始化的声明变量（只是 ）。相等运算符将 undefined 转换为 null，因此这适用于值类型和对象，这就是 CoffeeScript 处理可选参数的方式。var a1;

function overLoad(p1){
    alert(p1 == null); // Caution, don't use the strict comparison: === won't work.
    alert(typeof p1 === 'undefined');
}

overLoad(); // true, true
overLoad(undefined); // true, true. Yes, undefined is treated as null for equality operator.
overLoad(10); // false, false


function overLoad(p1){
    if (p1 == null) p1 = 'default value goes here...';
    //...
}

不过，有人担心，对于最好的语义来说，是稍微好一点。我不打算为此辩护，因为这是底层 API 如何实现函数的问题;它不应该引起 API 用户的兴趣。typeof variable === 'undefined'

我还应该补充一点，这是物理上确保遗漏任何参数的唯一方法，使用运算符，不幸的是，该运算符不适用于参数名称，因此必须传递 .inarguments

function foo(a, b) {
    // Both a and b will evaluate to undefined when used in an expression
    alert(a); // undefined
    alert(b); // undefined

    alert("0" in arguments); // true
    alert("1" in arguments); // false
}

foo (undefined);

对 undefined 的测试是不必要的，并且没有那么可靠，因为正如 user568458 指出的那样，如果通过 null 或 false，则提供的解决方案将失败。API 的用户可能会认为 false 或 null 会强制方法避免该参数。

function PaulDixonSolution(required, optionalArg){
   optionalArg = (typeof optionalArg === "undefined") ? "defaultValue" : optionalArg;
   console.log(optionalArg);
};
PaulDixonSolution("required");
PaulDixonSolution("required", "provided");
PaulDixonSolution("required", null);
PaulDixonSolution("required", false);

结果是：

defaultValue
provided
null
false

最后两个可能是坏的。相反，请尝试：

function bulletproof(required, optionalArg){
   optionalArg = optionalArg ? optionalArg : "defaultValue";;
   console.log(optionalArg);
};
bulletproof("required");
bulletproof("required", "provided");
bulletproof("required", null);
bulletproof("required", false);

其结果是：

defaultValue
provided
defaultValue
defaultValue

唯一不是最佳情况是，当您实际上具有应为布尔值或故意为 null 的可选参数时。

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

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

这就是我最终得到的：

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 foo(a, b, c) {
  a = a || "default";   // Matches 0, "", null, undefined, NaN, false.
  a || (a = "default"); // Matches 0, "", null, undefined, NaN, false.

  if (b == null) { b = "default"; } // Matches null, undefined.

  if (typeof c === "undefined") { c = "default"; } // Matches undefined.
}

例如，与变量一起使用的虚假默认值在Backbone.js中被广泛使用。a

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

人-

在查看了这些解决方案和其他解决方案之后，我尝试了其中的一些解决方案，并使用最初来自 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."; 

我尝试了这里提到的一些选项，并对其进行了性能测试。此时此刻，逻辑器似乎是最快的。尽管这会随着时间的推移而发生变化（不同的 JavaScript 引擎版本）。

这些是我的结果（Microsoft Edge 20.10240.16384.0）：

Function executed            Operations/sec     Statistics
TypeofFunction('test');          92,169,505     ±1.55%   9% slower
SwitchFuntion('test');            2,904,685     ±2.91%  97% slower
ObjectFunction({param1: 'test'});   924,753     ±1.71%  99% slower
LogicalOrFunction('test');      101,205,173     ±0.92%     fastest
TypeofFunction2('test');         35,636,836     ±0.59%  65% slower

此性能测试可以很容易地复制到： http://jsperf.com/optional-parameters-typeof-vs-switch/2

这是测试的代码：

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1/jquery.min.js"></script>
<script>
    Benchmark.prototype.setup = function() {
        function TypeofFunction(param1, optParam1, optParam2, optParam3) {
            optParam1 = (typeof optParam1 === "undefined") ? "Some default" : optParam1;
            optParam2 = (typeof optParam2 === "undefined") ? "Another default" : optParam2;
            optParam3 = (typeof optParam3 === "undefined") ? "Some other default" : optParam3;
        }

        function TypeofFunction2(param1, optParam1, optParam2, optParam3) {
            optParam1 = defaultValue(optParam1, "Some default");
            optParam2 = defaultValue(optParam2, "Another default");
            optParam3 = defaultValue(optParam3, "Some other default");
        }

        function defaultValue(variable, defaultValue) {
            return (typeof variable !== 'undefined') ? (variable) : (defaultValue);
        }

        function SwitchFuntion(param1, optParam1, optParam2, optParam3) {
            switch (arguments.length - 1) { // <-- 1 is number of required arguments
                case 0:
                    optParam1 = 'Some default';
                case 1:
                    optParam2 = 'Another default';
                case 2:
                    optParam3 = 'Some other default';
            }
        }

        function ObjectFunction(args) {
            var defaults = {
                optParam1: 'Some default',
                optParam2: 'Another default',
                optParam3: 'Some other default'
            }
            args = $.extend({}, defaults, args);
        }

        function LogicalOrFunction(param1, optParam1, optParam2, optParam3) {
            optParam1 || (optParam1 = 'Some default');
            optParam2 || (optParam1 = 'Another default');
            optParam3 || (optParam1 = 'Some other default');
        }
    };
</script>

如果你使用的是下划线库（你应该这样做，这是一个很棒的库）：

_.defaults(optionalArg, 'defaultValue');

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/

松散型检查

易于编写，但 、 、 和 将转换为默认值，这可能不是预期的结果。0''falsenullundefined

function myFunc(requiredArg, optionalArg) {
    optionalArg = optionalArg || 'defaultValue';
}

严格的类型检查

时间较长，但涵盖大多数情况。它错误地分配默认值的唯一情况是当我们作为参数传递时。undefined

function myFunc(requiredArg, optionalArg) {
    optionalArg = typeof optionalArg !== 'undefined' ? optionalArg : 'defaultValue';
}

检查参数变量

捕获所有情况，但编写起来最笨拙。

function myFunc(requiredArg, optionalArg1, optionalArg2) {
    optionalArg1 = arguments.length > 1 ? optionalArg1 : 'defaultValue';
    optionalArg2 = arguments.length > 2 ? optionalArg2 : 'defaultValue';
}

DSW的

不幸的是，目前浏览器支持很差

function myFunc(requiredArg, optionalArg = 'defaultValue') {

}

到了这个问题，在 EcmaScript 2015 中搜索默认参数，因此只是提到......

在 ES6 中，我们可以执行默认参数：

function doSomething(optionalParam = "defaultValue"){
    console.log(optionalParam);//not required to check for falsy values
}

doSomething(); //"defaultValue"
doSomething("myvalue"); //"myvalue"

使用ES2015/ES6，您可以利用它来取代或Object.assign$.extend()_.defaults()

function myFunc(requiredArg, options = {}) {
  const defaults = {
    message: 'Hello',
    color: 'red',
    importance: 1
  };

  const settings = Object.assign({}, defaults, options);

  // do stuff
}

您也可以使用像这样 defaults 参数

function myFunc(requiredArg, { message: 'Hello', color: 'red', importance: 1 } = {}) {
  // do stuff
}

在一个项目中，我注意到我在可选参数和设置上重复了太多，所以我创建了一个类来处理类型检查并分配一个默认值，从而产生简洁易读的代码。请参阅示例，让我知道这是否适合您。

var myCar           = new Car('VW', {gearbox:'automatic', options:['radio', 'airbags 2x']});
var myOtherCar      = new Car('Toyota');

function Car(brand, settings) {
    this.brand      = brand;

    // readable and adjustable code
    settings        = DefaultValue.object(settings, {});
    this.wheels     = DefaultValue.number(settings.wheels, 4);
    this.hasBreaks  = DefaultValue.bool(settings.hasBreaks, true);
    this.gearbox    = DefaultValue.string(settings.gearbox, 'manual');
    this.options    = DefaultValue.array(settings.options, []);

    // instead of doing this the hard way
    settings        = settings || {};
    this.wheels     = (!isNaN(settings.wheels)) ? settings.wheels : 4;
    this.hasBreaks  = (typeof settings.hasBreaks !== 'undefined') ? (settings.hasBreaks === true) : true;
    this.gearbox    = (typeof settings.gearbox === 'string') ? settings.gearbox : 'manual';
    this.options    = (typeof settings.options !== 'undefined' && Array.isArray(settings.options)) ? settings.options : [];
}

使用此类：

(function(ns) {

    var DefaultValue = {

        object: function(input, defaultValue) {
            if (typeof defaultValue !== 'object') throw new Error('invalid defaultValue type');
            return (typeof input !== 'undefined') ? input : defaultValue;
        },

        bool: function(input, defaultValue) {
            if (typeof defaultValue !== 'boolean') throw new Error('invalid defaultValue type');
            return (typeof input !== 'undefined') ? (input === true) : defaultValue;
        },

        number: function(input, defaultValue) {
            if (isNaN(defaultValue)) throw new Error('invalid defaultValue type');
            return (typeof input !== 'undefined' && !isNaN(input)) ? parseFloat(input) : defaultValue;
        },

        // wrap the input in an array if it is not undefined and not an array, for your convenience
        array: function(input, defaultValue) {
            if (typeof defaultValue === 'undefined') throw new Error('invalid defaultValue type');
            return (typeof input !== 'undefined') ? (Array.isArray(input) ? input : [input]) : defaultValue;
        },

        string: function(input, defaultValue) {
            if (typeof defaultValue !== 'string') throw new Error('invalid defaultValue type');
            return (typeof input === 'string') ? input : defaultValue;
        },

    };

    ns.DefaultValue = DefaultValue;

}(this));

这是我的解决方案。有了这个，你可以留下任何你想要的参数。可选参数的顺序并不重要，您可以添加自定义验证。

function YourFunction(optionalArguments) {
            //var scope = this;

            //set the defaults
            var _value1 = 'defaultValue1';
            var _value2 = 'defaultValue2';
            var _value3 = null;
            var _value4 = false;

            //check the optional arguments if they are set to override defaults...
            if (typeof optionalArguments !== 'undefined') {

                if (typeof optionalArguments.param1 !== 'undefined')
                    _value1 = optionalArguments.param1;

                if (typeof optionalArguments.param2 !== 'undefined')
                    _value2 = optionalArguments.param2;

                if (typeof optionalArguments.param3 !== 'undefined')
                    _value3 = optionalArguments.param3;

                if (typeof optionalArguments.param4 !== 'undefined')
                    //use custom parameter validation if needed, in this case for javascript boolean
                   _value4 = (optionalArguments.param4 === true || optionalArguments.param4 === 'true');
            }

            console.log('value summary of function call:');
            console.log('value1: ' + _value1);
            console.log('value2: ' + _value2);
            console.log('value3: ' + _value3);
            console.log('value4: ' + _value4);
            console.log('');
        }


        //call your function in any way you want. You can leave parameters. Order is not important. Here some examples:
        YourFunction({
            param1: 'yourGivenValue1',
            param2: 'yourGivenValue2',
            param3: 'yourGivenValue3',
            param4: true,
        });

        //order is not important
        YourFunction({
            param4: false,
            param1: 'yourGivenValue1',
            param2: 'yourGivenValue2',
        });

        //uses all default values
        YourFunction();

        //keeps value4 false, because not a valid value is given
        YourFunction({
            param4: 'not a valid bool'
        });

1. arg || 'default'是一种很好的方法，适用于 90% 的情况

2. 当您需要传递可能是“虚假”的值时，它会失败

   • false
   • 0
   • NaN
   • ""

   对于这些情况，您需要更详细一些，并检查undefined

3. 当你首先有可选参数时也要小心，你必须了解所有参数的类型

在 optionalArg 为 falsy 的所有情况下，您最终将得到 defaultValue。

function myFunc(requiredArg, optionalArg) {
    optionalArg = optionalArg || 'defaultValue';
    console.log(optionalArg);
    // Do stuff
}
myFunc(requiredArg);
myFunc(requiredArg, null);
myFunc(requiredArg, undefined);
myFunc(requiredArg, "");
myFunc(requiredArg, 0);
myFunc(requiredArg, false);

以上所有日志 defaultValue，因为所有 6 个都是假的。在情况 4、5、6 中，您可能对将 optionalArg 设置为 defaultValue 不感兴趣，但它设置了，因为它们是虚假的。

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

依靠 arguments 对象成员创建，如果缺少参数，甚至不会创建，无论它可能被声明的事实如何，我们都可以像这样编写函数：

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

利用此行为： 每当我们需要确保函数获得其过程中所需的特定值时，我们都可以安全地任意且显式地检查参数列表中的任何缺失值。

在下面的演示代码中，我们将特意将一个无类型和无值的 undefined 作为默认值，以便能够确定它是否可能在错误的参数值（例如 0 false 等）上失败，或者它是否按预期运行。

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 或三元条件。

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

但是，除了这种不便（在某些编码情况下可能是完全可以接受的）之外，还有另一个无法解释的问题，即多个和任意数量的参数默认值。这可能而且应该被视为一个错误，因为我们不能再跳过参数，就像我们曾经可以在不给出值的情况下跳过参数一样，在语法中：

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

因为它会扔！这使得我们无法用我们想要的默认值的特定虚假类型来替换我们的参数。 这很愚蠢，因为 arguments 对象是一个类似数组的对象，并且应该原生或默认支持这种语法和约定！

由于这个短视的决定，我们不能再指望写出这样的函数了：

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.：很抱歉在编写参数输入时没有保留所选默认值的类型。