arg||“默认”是一种很好的方法，适用于90%的情况当您需要传递可能“错误”的值时，它会失败假的0NaN公司""对于这些情况，您需要更加详细地检查未定义的当你首先有可选参数时，也要小心，你必须知道所有参数的类型

与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时，很容易接受所继承对象的构造函数所需的任何参数，因为您不必在构造函数签名中命名这些参数，或者甚至提供自己的默认值（让父对象的构造函数为您实现，正如上面CharField调用Field的构造函数时所看到的那样）。继承层次结构中的子对象可以根据需要为其父构造函数自定义参数，强制使用自己的默认值或确保始终使用某个值。

这些版本比操作员版本的类型短。

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

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

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

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

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

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

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

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

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

它的伸缩性很好：每个新默认值的额外代码最少您可以将其粘贴到任何位置：只需更改所需参数和变量的数量如果您想将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);
}

这是一个简单的例子。

如果需要插入一个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];

    // ...
}