Typescript手册提到了重载。虽然前面已经提到过检查类型和根据结果执行不同的逻辑，但这种定义多个命名函数来使用类型系统的方法可能会让读者感兴趣。下面是TypeScript如何实现创建一个接受多种类型参数的函数，这些参数将指导函数逻辑根据传入的参数和类型做不同的事情:

答案是为同一个函数提供多个函数类型作为重载列表。这个列表是编译器用来解析函数调用的。让我们创建一个重载列表，用来描述pickCard接收和返回的内容。

let suits = ["hearts", "spades", "clubs", "diamonds"];

function pickCard(x: { suit: string; card: number }[]): number;
function pickCard(x: number): { suit: string; card: number };
function pickCard(x: any): any {
  // Check to see if we're working with an object/array
  // if so, they gave us the deck and we'll pick the card
  if (typeof x == "object") {
    let pickedCard = Math.floor(Math.random() * x.length);
    return pickedCard;
  }
  // Otherwise just let them pick the card
  else if (typeof x == "number") {
    let pickedSuit = Math.floor(x / 13);
    return { suit: suits[pickedSuit], card: x % 13 };
  }
}

let myDeck = [
  { suit: "diamonds", card: 2 },
  { suit: "spades", card: 10 },
  { suit: "hearts", card: 4 },
];

let pickedCard1 = myDeck[pickCard(myDeck)];
alert("card: " + pickedCard1.card + " of " + pickedCard1.suit);

let pickedCard2 = pickCard(15);
alert("card: " + pickedCard2.card + " of " + pickedCard2.suit);

有了这个更改，重载现在为我们提供了对pickCard函数的类型检查调用。

为了让编译器选择正确的类型检查，它遵循与底层JavaScript类似的过程。它查看重载列表，然后继续执行第一个重载，尝试使用提供的参数调用函数。如果找到匹配项，则选择此重载作为正确的重载。出于这个原因，通常按照最特定到最不特定的顺序对重载进行排序。

注意，函数pickCard(x):任何块都不是重载列表的一部分，因此它只有两个重载:一个接受对象，另一个接受数字。用任何其他参数类型调用pickCard都会导致错误。

你现在可以在ECMAScript 2018中进行函数重载，而无需填充，检查var长度/类型等，只需使用扩展语法。

function foo(var1, var2, opts){ // set default values for parameters const defaultOpts = { a: [1,2,3], b: true, c: 0.3289, d: "str", } // merge default and passed-in parameters // defaultOpts must go first! const mergedOpts = {...defaultOpts, ...opts}; // you can now refer to parameters like b as mergedOpts.b, // or just assign mergedOpts.b to b console.log(mergedOpts.a); console.log(mergedOpts.b); console.log(mergedOpts.c); console.log(mergedOpts.d); } // the parameters you passed in override the default ones // all JS types are supported: primitives, objects, arrays, functions, etc. let var1, var2="random var"; foo(var1, var2, {a: [1,2], d: "differentString"}); // parameter values inside foo: //a: [1,2] //b: true //c: 0.3289 //d: "differentString"

什么是扩展语法?

ECMAScript提案的Rest/Spread Properties(阶段4)将扩展属性添加到对象字面量中。它将自己的可枚举属性从提供的对象复制到新对象上。 更多关于mdn

注意:对象字面量中的扩展语法在Edge和IE中不起作用，这是一个实验特性。查看浏览器兼容性

所以我真的很喜欢这种做事的方式，这是我在javascript忍者的秘密中发现的

function addMethod(object,name,fn){
  var old = object[name];
  object[name] = function(){
    if (fn.length == arguments.length){
      return fn.apply(this,arguments);
    } else if(typeof old == 'function'){
        return old.apply(this,arguments);
    }
  }
}

然后使用addMethod将重载函数添加到任何对象。对我来说，这段代码中的主要困惑是fn的使用。Length ==参数。长度，这是因为fn。长度是预期参数的数量，而参数。长度是函数实际调用的参数的数量。匿名函数没有参数的原因是你可以在javascript中传入任意数量的参数，并且语言是宽容的。

我喜欢这个，因为你可以在任何地方使用它-只需创建这个函数，并在任何你想要的代码库中简单地使用这个方法。

它还避免了一个大得离谱的if/switch语句，如果您开始编写复杂的代码，它将变得难以阅读(接受的答案将导致这种结果)。

在缺点方面，我想代码一开始有点晦涩……但我不确定其他人?

不是每个人都知道可以在函数签名中直接进行解构赋值。

得益于此，您可以轻松地定义非常灵活的方法签名，恕我直言，这比Java方法重载更优越。

例子:

const myFunction = (({a, b, c}) => {
    console.log(a, b, c);
});

myFunction({a: 1, b: 2});
myFunction({a: 1, b: 2, c: 3});

您甚至不需要考虑参数的顺序，并且调用语句和目标方法签名之间具有命名一致性。

你也可以指定默认值:

const myFunction = (({a = 1, b = 2, c} = {}) => {
    console.log(a, b, c);
});

介绍

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

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

最简单形式的函数重载意味着函数根据传递给它的参数数量执行不同的任务。值得注意的是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);

Javascript中的函数重载:

函数重载是一种编程语言用不同的实现创建多个同名函数的能力。当重载函数被调用时，它将运行该函数的特定实现，以适应调用的上下文。这个上下文通常是接收参数的数量，它允许一个函数调用根据上下文表现不同。

Javascript没有内置的函数重载。然而，这种行为可以通过许多方式来模仿。这里有一个简单方便的例子:

函数sayHi(a, b) { Console.log ('hi there ' + a); 如果(b) {console.log('and ' + b)} //如果参数存在，则执行该块 ｝ sayHi(“弗兰克”,“威廉”);

在你不知道你将得到多少参数的情况下，你可以使用rest操作符，即三点....它将把剩余的参数转换为一个数组。但是要注意浏览器的兼容性。这里有一个例子:

函数foo (a，…b) { console.log (b); ｝ foo(1、2、3、4); foo(1、2);