我总是这样处理 JavaScript 中的可选参数：
function myFunc(requiredArg, optionalArg){
optionalArg = optionalArg || 'defaultValue';
// Do stuff
}
有更好的方法吗？
有没有这样使用||会失败的情况？
Mark Biek
问问题
459349 次
28 回答
1096
如果 optionalArg 被传递，您的逻辑将失败，但评估为 false - 试试这个作为替代
if (typeof optionalArg === 'undefined') { optionalArg = 'default'; }
或另一种成语：
optionalArg = (typeof optionalArg === 'undefined') ? 'default' : optionalArg;
使用最能向您传达意图的成语！
于 2008-09-29T14:30:34.013 回答
180
在ECMAScript 2015（又名“ ES6 ”）中，您可以在函数声明中声明默认参数值：
function myFunc(requiredArg, optionalArg = 'defaultValue') {
// do stuff
}
有关它们的更多信息，请参阅 MDN 上的这篇文章。
目前只有 Firefox 支持，但随着标准的完成，预计支持会迅速提高。
编辑（2019-06-12）：
现代浏览器现在广泛支持默认参数。
所有版本的 Internet Explorer都不支持此功能。但是，Chrome、Firefox和Edge目前支持它。
于 2013-02-19T13:13:54.843 回答
127
我发现这是最简单、最易读的方式：
if (typeof myVariable === 'undefined') { myVariable = 'default'; }
//use myVariable here
Paul Dixon 的回答（以我的拙见）比这更难读，但归结为偏好。
insin 的答案要先进得多，但对大功能更有用！
编辑 2013 年 11 月 17 日晚上 9:33：我为 Node.js 创建了一个包，可以更轻松地“重载”名为parametric的函数（方法） 。
于 2011-11-14T21:23:59.627 回答
45
如果您需要插入文字NULL，那么您可能会遇到一些问题。除此之外，不，我认为您可能走在正确的轨道上。
一些人选择的另一种方法是使用一个 assoc 变量数组来遍历参数列表。它看起来有点整洁，但我想它有点（非常少）有点更多的进程/内存密集型。
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];
// ...
}
于 2008-09-29T14:34:33.300 回答
33
理想情况下，您将重构以传递一个对象并将其与默认对象合并，因此传递参数的顺序无关紧要（请参阅下面的此答案的第二部分）。
但是，如果您只是想要快速、可靠、易于使用且不笨重的东西，试试这个：
一个干净的快速修复任意数量的默认参数
- 它可以优雅地扩展：每个新默认值的额外代码最少
- 您可以将其粘贴到任何地方：只需更改所需参数和变量的数量
- 如果要传递
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 的答案，但可以轻松扩展任意数量的默认参数，更易于更新和使用argumentsnotFunction.arguments。
传递和合并对象以获得更大的灵活性
上面的代码，就像许多执行默认参数的方法一样，不能乱序传递参数，例如，传递optionalC但离开optionalB以回退到其默认值。
一个不错的选择是传递对象并与默认对象合并。这也有利于可维护性（只需注意保持代码的可读性，这样未来的合作者就不会猜测您传递的对象的可能内容）。
使用 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);
}
这是一个简单的例子。
于 2012-02-20T15:36:26.000 回答
19
您可以为此使用一些不同的方案。我一直在测试arguments.length：
function myFunc(requiredArg, optionalArg){
optionalArg = myFunc.arguments.length<2 ? 'defaultValue' : optionalArg;
...
——这样做，它不可能失败，但我不知道你的方式是否有任何失败的机会，刚才我想不出一个场景，它实际上会失败......
然后保罗提供了一个失败的场景！-)
于 2008-09-29T14:33:31.447 回答
13
与 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 个参数并且您只想自定义最后一个一，因为您必须使用建议的其他一些方法。 - 当为从另一个继承的对象使用构造函数时，很容易接受您继承的对象的构造函数所需的任何参数，因为您不必在构造函数签名中命名这些参数，甚至提供您自己的默认值（让父对象的构造函数为您执行此操作，如上面
CharField调用Field的构造函数时所见）。 - 继承层次结构中的子对象可以根据需要为其父构造函数自定义参数，强制执行自己的默认值或确保始终使用某个值。
于 2008-09-29T23:16:54.823 回答
9
松散类型检查
易于编写，但是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') {
}
于 2015-05-15T13:46:57.200 回答
8
如果您广泛使用默认值，这似乎更具可读性：
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 中的保留字。
于 2012-05-15T21:23:50.220 回答
6
我习惯于看到处理可选变量的一些基本变化。有时，轻松的版本很有用。
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中广泛使用。
于 2014-03-13T06:27:04.113 回答
6
使用 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
}
于 2016-02-01T11:09:53.710 回答
3
如果你正在使用Underscore库（你应该，它是一个很棒的库）：
_.defaults(optionalArg, 'defaultValue');
于 2014-09-22T23:59:46.110 回答
2
我不知道为什么@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不幸的是不能与参数名称一起使用的运算符，因此必须传递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);
于 2013-05-07T13:31:33.740 回答
2
对 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
这不是最佳的唯一情况是当您实际上有可选参数时，这些参数是布尔值或有意为空的。
于 2013-09-27T05:15:30.203 回答
2
我尝试了此处提到的一些选项并对其进行了性能测试。此时逻辑或似乎是最快的。尽管这是随时间变化的主题（不同的 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>
于 2014-06-19T11:25:54.337 回答
2
登陆这个问题，在 EcmaScript 2015 中搜索默认参数，因此只是提到......
使用ES6我们可以做默认参数：
function doSomething(optionalParam = "defaultValue"){
console.log(optionalParam);//not required to check for falsy values
}
doSomething(); //"defaultValue"
doSomething("myvalue"); //"myvalue"
于 2015-10-09T14:19:21.863 回答
2
在一个项目中，我注意到我在可选参数和设置方面重复了太多，所以我创建了一个类来处理类型检查并分配一个默认值，从而产生整洁且可读的代码。请参阅示例，让我知道这是否适合您。
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));
于 2016-03-23T10:52:48.300 回答
1
这就是我最终的结果：
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" });
于 2013-11-29T21:04:58.937 回答
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.";
于 2014-04-13T20:53:23.117 回答
1
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);
于 2014-10-03T09:28:30.883 回答
1
这是我的解决方案。有了这个，你可以留下任何你想要的参数。可选参数的顺序并不重要，您可以添加自定义验证。
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'
});
于 2016-04-11T13:51:11.817 回答
1
arg || 'default'是一种很好的方法，适用于 90% 的情况当您需要传递可能是“虚假”的值时，它会失败
false0NaN""
对于这些情况，您需要更详细一些并检查
undefined当你首先有可选参数时也要小心，你必须知道所有参数的类型
于 2016-04-30T19:36:34.467 回答
1
在 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);
上面所有的log都是defaultValue，因为6个都是falsy。在第 4、5、6 种情况下，您可能对将 optionalArg 设置为 defaultValue 不感兴趣，但由于它们是虚假的，因此它会设置。
于 2016-09-02T04:16:30.933 回答
0
如果我错了，请纠正我，但这似乎是最简单的方法（无论如何，对于一个论点）：
function myFunction(Required,Optional)
{
if (arguments.length<2) Optional = "Default";
//Your code
}
于 2013-02-21T02:03:10.320 回答
0
这些比 typeof 运算符版本短。
function foo(a, b) {
a !== undefined || (a = 'defaultA');
if(b === undefined) b = 'defaultB';
...
}
于 2013-11-07T18:05:53.480 回答
-1
我建议你以这种方式使用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
}
于 2013-04-12T15:35:28.207 回答
-1
似乎最安全的方法 -在决定使用默认值之前处理所有\任何虚假类型的提供参数- 是检查调用函数中可选参数的存在\存在。
依赖于参数对象成员的创建，如果参数丢失，它甚至不会被创建，不管它可能被声明，我们可以这样编写你的函数：
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
这意味着 - 他们没有未能识别/作为预期的参数值。在这里，我们检查了所有参数是否丢失，根据我们的算法，即使它们是falsy也应该获取它们的默认值。
argCheck( );
>> undefined false 0 null
正如我们所看到的，参数arg1、arg2、arg3和未声明的arg4正在按顺序返回它们的确切默认值。因为我们现在已经确定它可以工作，所以我们可以重写函数，它实际上可以像第一个示例中那样使用它们，方法是使用：if或三元条件。
在具有多个可选参数的函数上， - 循环，可能会为我们节省一些代码。但是由于参数名称如果没有提供它们的值就不会被初始化，即使我们以编程方式编写了默认值，我们也不能再通过名称访问它们，我们只能通过arguments[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：很抱歉在编写它们时没有在我的参数输入中保留所选默认值的类型。
于 2016-10-29T03:44:18.487 回答
-2
function foo(requiredArg){
if(arguments.length>1) var optionalArg = arguments[1];
}
于 2014-04-09T02:03:42.667 回答