有没有更好的方法在JavaScript中执行可选函数参数?[重复]

2020/09/20 11:31 · javascript ·  · 0评论

我一直像这样处理JavaScript中的可选参数:

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

  // Do stuff
}

有更好的方法吗?

有没有在这种情况下使用||会失败的情况?

如果传递了optionalArg,您的逻辑将失败,但评估为false-尝试使用此方法

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

或另一种习语:

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

使用任何一种最能传达您意图的习语!

ECMAScript 2015(又名“ ES6 ”)中,您可以在函数声明中声明默认参数值:

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

有关MDN的更多信息,请参见本文

当前仅Firefox支持此功能,但是随着标准的完成,希望支持会迅速提高。


编辑(2019-06-12):

现在,现代浏览器广泛支持默认参数。

Internet
Explorer的所有版本都不支持此功能。但是,ChromeFirefoxEdge当前支持它。

我发现这是最简单,最易读的方式:

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

保罗·迪克森(Paul Dixon)的答案(以我的拙见)比这更难读,但最终取决于偏好。

insin的答案要高级得多,但对大型函数而言却有用得多!

EDIT 11/17/2013 9:33 pm:我为Node.js创建了一个程序包,可以更轻松地“重载”称为parametric的函数(方法)

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

    // ...
}

理想情况下,您将重构以传递对象并将其与默认对象合并,因此传递参数的顺序无关紧要(请参见下面的答案的第二部分)。

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


一个干净的快速修复程序,可用于任意数量的默认参数

  • 它可以优雅地扩展:每个新默认值的额外代码最少
  • 您可以将其粘贴到任何地方:只需更改所需的args和变量的数量
  • 如果要传递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的答案,但可以轻松扩展为任意数量的默认参数,更易于更新,并且使用argumentsFunction.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);
}

这是一个实际的例子

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

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

  ...

-这样做可能不会失败,但是我不知道您的方式是否有失败的机会,只是现在我无法想到一个实际会失败的情况...

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

与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的构造函数时所见)。
  • 继承层次结构中的子对象可以为其父构造函数自定义自定义参数,从而强制执行其自己的默认值或确保始终使用某个特定值

松散类型检查

容易写,但是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';
}

ES6

不幸的是,目前这对浏览器的支持很差

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

}

如果您广泛使用默认值,那么这似乎更具可读性:

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

只需在全局范围内声明此函数即可。

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

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

* PS,您可以将defaultValue函数重命名为短名称,只是不要使用default它是javascript中的保留字。

借助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
}

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

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中广泛使用

如果您使用的是Underscore库(应该,那是一个很棒的库):

_.defaults(optionalArg, 'defaultValue');

落到这个问题上,在EcmaScript 2015中搜索默认参数,因此仅提及...

使用ES6,我们可以执行默认参数

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

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

在一个项目中,我注意到我在可选参数和设置上重复了太多的事情,因此我制作了一个用于处理类型检查并分配默认值的类,该默认值导致代码整洁可读。查看示例,让我知道这是否适合您。

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

我不知道为什么@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);

对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时。

我尝试了此处提到的一些选项,并对它们进行了性能测试。这时逻辑家似乎是最快的。尽管这是随时间变化的主题(不同的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>

我最终得到的是:

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

民间-

看完这些和其他解决方案后,我使用了最初来自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 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 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都是错误的,您最终将得到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,但是由于它们是虚假的,因此会进行设置。

如果我错了,请纠正我,但这似乎是最简单的方法(无论如何对于一个参数):

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

那些比typeof运算符版本短。

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

我建议您以这种方式使用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 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三元条件。

在具有多个可选参数的函数上-循环访问可能为我们节省了一些时间。但是,由于如果未提供参数名称,则不会初始化参数名称,因此即使我们已经以编程方式编写了默认值,也无法通过名称访问它们,因此只能通过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:很抱歉在编写参数时没有在我的参数输入中保留所选默认类型

function foo(requiredArg){
  if(arguments.length>1) var optionalArg = arguments[1];
}
本文地址:http://javascript.askforanswer.com/youmeiyougenghaodefangfazaijavascriptzhongzhixingkexuanhanshucanshuzhongfu.html
文章标签: ,   ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!