使用ES2015/ES6，您可以利用Object.assign，它可以替换$.exd（）或_.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
}

乡亲们-

在研究了这些和其他解决方案之后，我使用最初来自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."; 

似乎最安全的方法-在决定使用默认值之前处理所有提供的错误类型的参数-是检查所调用函数中是否存在可选参数。

依赖于arguments对象成员创建（如果缺少参数，甚至不会创建），无论它可能被声明，我们都可以这样编写函数：

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

现在，检查几个错误的参数值，看看是否正确检测到它们的存在，并因此计算为真：

argCheck( "", 0, false, null );
>> true true true true

这意味着-它们没有将/识别为预期的参数值。这里我们检查了所有参数的缺失，根据我们的算法，即使它们是假的，也应该获取它们的默认值。

argCheck( );
>> undefined false 0 null

如我们所见，参数arg1、arg2、arg3和未声明的arg4按顺序返回其确切的默认值。因为我们现在已经确定了它的有效性，所以我们可以重写函数，该函数实际上可以像第一个示例中那样使用它们，方法是使用if或三元条件。

对于具有多个可选参数的函数，-循环，可能会为我们节省一些时间。但是，由于如果不提供参数名称的值，则参数名称不会被初始化，因此即使我们以编程方式编写了默认值，我们也无法再通过名称访问它们，因此只能通过参数[索引]访问它们，这对代码的可读性来说是无用的。

但除了在某些编码情况下可能完全可以接受的这种不便之外，还有一个未知的问题，即多个任意数量的参数默认值。这可能也应该被认为是一个错误，因为我们不能再跳过参数，因为我们曾经可以在不提供值的情况下，使用如下语法：

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

在这种情况下，我们将能够在arguments行中写入所需类型的每个默认值，并且至少能够通过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 );
}

p.s.：很抱歉，在编写参数输入时没有保留所选默认值的类型。

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

    // ...
}

我尝试了这里提到的一些选项，并对它们进行了性能测试。此时此刻，逻辑学家似乎是最快的。尽管这会随着时间的推移而改变（不同的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>

如果您正在使用Undercore库（您应该这样做，这是一个很棒的库）：

_.defaults(optionalArg, 'defaultValue');