我建议您这样使用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 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函数重命名为短名称，只是不要使用默认值，这是javascript中的保留字。

function foo(requiredArg){
  if(arguments.length>1) var optionalArg = arguments[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'
        });

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

然而，如果你只是想要一些快速、可靠、易于使用且体积不大的东西，请尝试一下：

对任意数量的默认参数的快速修复

它的伸缩性很好：每个新默认值的额外代码最少您可以将其粘贴到任何位置：只需更改所需参数和变量的数量如果您想将undefined传递给具有默认值的参数，那么这种方式会将变量设置为undefineed。此页面上的大多数其他选项将用默认值替换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的答案类似，但很容易扩展到任意数量的默认参数，更容易更新，并且使用的参数不是Function.arguments。

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

上面的代码和许多默认参数的方法一样，不能按顺序传递参数，例如，传递optionalC，但让optionalB返回默认值。

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

使用jQuery的示例。如果不使用jQuery，可以改用Undercore的_.defaults（对象，默认值）或浏览以下选项：

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

这是一个简单的例子。

我认为这是最简单、最易读的方法：

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

保罗·迪克森（Paul Dixon）的回答（我个人认为）不如这一点可读，但归根结底是偏好。

impin的答案要高级得多，但对于大函数来说更有用！

2013年11月17日晚上9:33编辑：我为Node.js创建了一个包，它可以更容易地“重载”称为参数化的函数（方法）。