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

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

与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的构造函数时所看到的那样）。继承层次结构中的子对象可以根据需要为其父构造函数自定义参数，强制使用自己的默认值或确保始终使用某个值。

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

    // ...
}

松散类型检查

易于编写，但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') {

}

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

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

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

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

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

这就是我的结局：

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