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

Question

这个问题在这里已经有了答案：

为 JavaScript 函数设置默认参数值（29 个回答）

4年前关闭。

我总是像这样在 JavaScript 中处理可选参数：

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

  // Do stuff
}

有没有更好的方法来做到这一点？

有没有使用|| 这样会失败吗？

Answer 1

如果通过 optionalArg，您的逻辑将失败，但评估为 false - 试试这个作为替代

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

或者另一种习语：

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

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

Answer 2

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

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

在 MDN 上的这篇文章中有更多关于它们的信息。

目前只有 Firefox 支持，但随着标准的完成，预计支持会迅速改进。

---

编辑（2019-06-12）：

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

Answer 3

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

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

保罗迪克森的回答（以我的拙见）比这更难读，但这归结为偏好。

insin 的答案要先进得多，但对大功能更有用！

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

Answer 4

如果您需要插入文字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];

    // ...
}

Answer 5

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

但是，如果您只想要快速、可靠、易于使用且不笨重的东西，请尝试以下操作：

---

任何数量的默认参数的干净快速修复

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

这是为三个可选参数提供默认值的示例（带有两个必需参数）

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 的 answer ，但很容易扩展为任意数量的默认参数，更容易更新，并且使用的arguments不是Function.arguments 。

---

传递和合并对象以获得更大的灵活性

上面的代码，像许多处理默认参数的方法一样，不能乱序传递参数，例如，传递optionalC但让optionalB回退到它的默认值。

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

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

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

这是一个简单的例子。

Answer 6

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

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

  ...

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

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

Answer 7

与 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)

这种方法有什么好处？

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

Answer 8

松散类型检查

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

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';
}

ES6

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

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

}

Answer 9

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

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 您可以将defaultValue函数重命名为短名称，只是不要使用default它是 javascript 中的保留字。

Answer 10

使用 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
}

您还可以使用这样的默认参数

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

Answer 11

我习惯于看到处理可选变量的一些基本变化。 有时，放松的版本很有用。

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.
}

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

Answer 12

如果您正在使用Underscore库（您应该这样做，它是一个很棒的库）：

_.defaults(optionalArg, 'defaultValue');

Answer 13

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

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

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...';
    //...
}

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

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

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

Answer 14

对 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

这不是最佳的唯一情况是当您实际上有意味着是布尔值或有意为空的可选参数时。

Answer 15

我尝试了这里提到的一些选项并对其进行了性能测试。 在这一刻，逻辑或似乎是最快的。 尽管这是随时间变化的主题（不同的 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>

Answer 16

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

使用ES6我们可以做默认参数：

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

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

Answer 17

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

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

Answer 18

这就是我最终的结果：

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

Answer 19

各位——

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

Answer 20

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/

Answer 21

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

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

Answer 22

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

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

   • false
   • 0
   • NaN
   • ""

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

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

Answer 23

在所有 optionalArg 为假的情况下，您最终都会得到 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个都是falsy。 在第 4、5、6 种情况下，您可能对将 optionalArg 设置为 defaultValue 不感兴趣，但它会设置，因为它们是假的。

Answer 24

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

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

Answer 25

那些比 typeof 运算符版本短。

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

Answer 26

我建议你这样使用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

}

Answer 27

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

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

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

利用这种行为：只要我们需要确保函数获得其过程中所需的某个值，我们就可以安全地任意明确地检查参数列表中的任何缺失值。

在下面的演示代码，我们会故意把一个无类型和无价值的未定义为默认值，以便能够确定它是否会在falsy参数值失败，如0虚假等，或者如果它的行为与预期。

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

这意味着 - 他们没有未能识别/作为预期的参数值。 在这里，我们检查了所有缺少的参数，根据我们的算法，即使它们是falsy也应该获取它们的默认值。

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

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

Answer 28

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