因为这篇文章已经包含了很多不同的解决方案，所以我想再发一个。

function onlyUnique(value, index, self) {
    return self.indexOf(value) === index;
}

function overload() {
   var functions = arguments;
   var nroffunctionsarguments = [arguments.length];
    for (var i = 0; i < arguments.length; i++) {
        nroffunctionsarguments[i] = arguments[i].length;
    }
    var unique = nroffunctionsarguments.filter(onlyUnique);
    if (unique.length === arguments.length) {
        return function () {
            var indexoffunction = nroffunctionsarguments.indexOf(arguments.length);
            return functions[indexoffunction].apply(this, arguments);
        }
    }
    else throw new TypeError("There are multiple functions with the same number of parameters");

}

这可以使用如下所示:

var createVector = overload(
        function (length) {
            return { x: length / 1.414, y: length / 1.414 };
        },
        function (a, b) {
            return { x: a, y: b };
        },
        function (a, b,c) {
            return { x: a, y: b, z:c};
        }
    );
console.log(createVector(3, 4));
console.log(createVector(3, 4,5));
console.log(createVector(7.07));

这个解决方案不是完美的，但我只想演示它是如何做到的。

用形参重载函数的最好方法不是检查实参长度或类型;检查类型只会让你的代码变慢，你可以享受数组、空值、对象等的乐趣。

大多数开发人员所做的是将一个对象作为方法的最后一个参数。这个物体可以装任何东西。

function foo(a, b, opts) {
  // ...
  if (opts['test']) { } //if test param exists, do something.. 
}


foo(1, 2, {"method":"add"});
foo(3, 4, {"test":"equals", "bar":"tree"});

然后你可以在你的方法中任意处理它。[开关，if-else，等等]

介绍

到目前为止，阅读这么多答案会让任何人感到头疼。任何试图了解这个概念的人都需要知道以下先决条件。

函数重载定义，函数长度属性，函数参数属性

最简单形式的函数重载意味着函数根据传递给它的参数数量执行不同的任务。值得注意的是TASK1, TASK2和TASK3在下面突出显示，它们是根据传递给同一个函数fooYo的参数数量来执行的。

// if we have a function defined below
function fooYo(){
     // do something here
}
// on invoking fooYo with different number of arguments it should be capable to do different things

fooYo();  // does TASK1
fooYo('sagar'); // does TASK2
fooYo('sagar','munjal'); // does TAKS3

请注意 JS不提供内置的函数重载功能。

替代

John E Resig (JS的创建者)指出了一种替代方法，它使用上述先决条件来实现函数重载的能力。

下面的代码通过使用if-else或switch语句使用了一种简单但简单的方法。

计算参数长度属性。 不同的值导致调用不同的函数。

Var ninja = { function() { 切换(arguments.length) { 例0: /*做某事*/ 打破; 案例1: /* do something else */ 打破; 案例2: /*做其他事情*/ 打破; //等等… ｝ ｝ ｝

另一种技术更加简洁和动态。这项技术的亮点是addMethod泛型函数。

我们定义了一个addMethod函数，它用于向一个对象添加不同的函数，这些函数具有相同的名称但不同的功能。 下面的addMethod函数接受三个参数:对象名称object，函数名称name和我们想要调用的函数fn。 在addMethod定义中，var old存储了对前一个函数的引用，该函数通过闭包(一个保护气泡)的帮助存储。

函数addMethod(对象，名称，fn) { Var old =对象[name]; 对象[name] = function(){ 如果(fn)。Length == arguments.length) 返回fn。应用(这个参数) Else if (typeof old == 'function') 返回旧。应用(这个参数); }; };

使用调试器来理解代码流。 下面的addMethod添加了三个函数，当使用ninja.whatever(x)调用时，参数x的数量可以是任何东西，即空白或一个或多个调用不同的函数定义，同时使用addMethod函数。

Var ninja = {}; 调试器; addMethod(ninja，'whatever'，function(){console.log("我是那个提供了零参数的人")}); addMethod(ninja，'whatever'，function(a){console.log("我是提供了一个参数的人")}); addMethod(ninja，'whatever'，function(a,b){console.log("我是一个提供了两个参数的人")}); ninja.whatever (); ninja.whatever(1、2); ninja.whatever (3);

#转发模式=> JS重载的最佳实践 转到另一个函数，它的名字是由第3和第4点构建的:

使用参数数量 检查参数类型

window['foo_'+arguments.length+'_'+Array.from(arguments).map((arg)=>typeof arg).join('_')](...arguments)

#应用于您的案例:

 function foo(...args){
          return window['foo_' + args.length+'_'+Array.from(args).map((arg)=>typeof arg).join('_')](...args);

  }
   //------Assuming that `x` , `y` and `z` are String when calling `foo` . 
  
  /**-- for :  foo(x)*/
  function foo_1_string(){
  }
  /**-- for : foo(x,y,z) ---*/
  function foo_3_string_string_string(){
      
  }

#其他复杂样本:

      function foo(...args){
          return window['foo_'+args.length+'_'+Array.from(args).map((arg)=>typeof arg).join('_')](...args);
       }

        /** one argument & this argument is string */
      function foo_1_string(){

      }
       //------------
       /** one argument & this argument is object */
      function foo_1_object(){

      }
      //----------
      /** two arguments & those arguments are both string */
      function foo_2_string_string(){

      }
       //--------
      /** Three arguments & those arguments are : id(number),name(string), callback(function) */
      function foo_3_number_string_function(){
                let args=arguments;
                  new Person(args[0],args[1]).onReady(args[3]);
      }
     
       //--- And so on ....   

我刚试过了，也许能满足你的需要。 根据参数的数量，您可以访问不同的函数。在第一次调用时初始化它。 函数映射隐藏在闭包中。

TEST = {};

TEST.multiFn = function(){
    // function map for our overloads
    var fnMap = {};

    fnMap[0] = function(){
        console.log("nothing here");
        return this;    //    support chaining
    }

    fnMap[1] = function(arg1){
        //    CODE here...
        console.log("1 arg: "+arg1);
        return this;
    };

    fnMap[2] = function(arg1, arg2){
        //    CODE here...
        console.log("2 args: "+arg1+", "+arg2);
        return this;
    };

    fnMap[3] = function(arg1,arg2,arg3){
        //    CODE here...
        console.log("3 args: "+arg1+", "+arg2+", "+arg3);
        return this;
    };

    console.log("multiFn is now initialized");

    //    redefine the function using the fnMap in the closure
    this.multiFn = function(){
        fnMap[arguments.length].apply(this, arguments);
        return this;
    };

    //    call the function since this code will only run once
    this.multiFn.apply(this, arguments);

    return this;    
};

测试它。

TEST.multiFn("0")
    .multiFn()
    .multiFn("0","1","2");

有两种方法可以更好地解决这个问题:

如果您希望保留很大的灵活性，则传递一个字典(关联数组) 将一个对象作为参数，并使用基于原型的继承来增加灵活性。