#include <iostream>
using namespace std;

void print(int i) {
   cout <<"Here is num " << i << endl;
}
void print(string str) {
   cout << "Here is string " <<str<< endl;
}
int main() {
   print(10);//Here is int 10
   print("ten");//Here is string ten
}

可以发现在C++中会根据参数的类型自动选择合适的函数执行，如果把上面的代码改造成Javascript代码如下：

function print(i) {
	console.log("Here is num"+i);
}

function print(str) {
	console.log("Here is string "+str);
}

print(100);//Here is string 100

print("ten");//Here is string ten

显然，这个例子中声明了两个同名函数，而结果则是后面的函数覆盖了前面的函数。那Javascript中到底有没有函数重载特性，

在《JS高程》中有这样一段总结：Javascript函数不能像传统意义上那样实现重载。而在其他语言（如 Java、C++）中，可以为一个函数编写两个定义，只要这两个定义的签名（接受的参数的类型和数量）不同即可。但是Javascript函数没有签名，因为其参数是由包含零或多个值的数组来表示的。而没有函数签名，真正的重载是不可能做到的。如果在 Javascript中定义了两个名字相同的函数，则该名字只属于后定义的函数。

function printNum(num) {
	console.log("Here is num "+num);
}
function printString(str) {
	console.log("Here is string "+str);
}
printNum(100);//Here is num 100
printString("ten");//Here is string ten

上述这种做法实际上已经违背了函数重载的基本特性，因为已经出现了不同的函数名。

function print(num,str){
	var inner_num=num||0;
	var inner_str=str||"default";
	console.log("Here is num "+inner_num);
	console.log("Here is string "+inner_str);
}

print();
//Here is num 0
//Here is string default
print(10);
//Here is num 10
//Here is string default
print(10,"ten");
//Here is num 10
//Here is string ten

使用这种方法的结果也是显而易见的，实现起来也是相当简单，在Javascript程序中被大量采用，但是执行print( ,"ten");这样的操作会发生错误，在某些情况下如果0/null/undefined为有效值时，执行y = y || 'default'会不分青红皂白的把这些值过滤掉。

function print(num,str){
	var len=arguments.length;
	if (len===1) {
		console.log("Here is num "+num);
	}
	else if (len===2) {
		console.log("Here is num "+num);
		console.log("Here is string "+str);
	}

	else{
		console.log("看....,飞碟！");
	}

}

print();//看....,飞碟！

print(10);//Here is num 10

print(10,"ten");
//Here is num 10
//Here is string ten

从上面的结果看，如果出入的参数只有一个字符串，仍然无法打印。

 function print(num,str){
	
	if (typeof num=="number") {
		console.log("Here is num "+num);
	}
	if (typeof str=="string") {
		console.log("Here is string "+str);
	}
}


print();//无输出

print(10);//Here is num 10
print('',"ten");//Here is string ten
print(10,"ten");
// Here is num 10
// Here is string ten

这种方法的结果算是比较满足函数重载的行为了，但是有没有发现如果只想打印字符串时，也不得不传入两个参数，并且要求开发人员知道函数内部能过滤掉第一个参数，同时检测参数数量和参数类型可以解决这个问题。

下面的例子中直接借用了arguments数组

 

 function print(num,str){
 	var len=arguments.length;
 	if((len===1)&& (typeof arguments[0]==="number")){
 		console.log("Here is num "+arguments[0]);
 	}
 	else if ((len===1)&& (typeof arguments[0]==="string")) {
 		console.log("Here is string "+arguments[0]);
 	}
 	else if((len===2)&& (typeof arguments[0]==="number")&& (typeof arguments[1]==="string")) {
 			console.log("Here is num "+arguments[0]);
 			console.log("Here is string "+arguments[1]);
 	}
	else{
		console.log("看....,飞碟！");
	}

}


print();//看....,飞碟！

print(10);//Here is num 10

print("ten");//Here is string ten

print(10,"ten");
// Here is num 10
// Here is string ten

function foo(a, b, opts) {

}

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

在代码中只需要检测对象的某个键值是否存在来做相应处理。

function sayName(name){
alert(name);
}
function sum(num1, num2){
return num1 + num2;
}
function sayHi(){
alert("hi");
}
alert(sayName.length); //1
alert(sum.length); //2
alert(sayHi.length); //0

因此，对于一个函数，在参数方面，我们可以确定两件事
■ 通过其length属性，可以知道声明了多少命名参数
■ 通过arguments.length，可以知道在调用时传入了多少参数
下面介绍一下大牛是如何实现借助这个特性实现函数的重载的

var ninja = {};
addMethod(ninja,'whatever',function(){ /* do something */ });
addMethod(ninja,'whatever',function(a){ /* do something else */ });
addMethod(ninja,'whatever',function(a,b){ /* yet something else */ });

在这里，先创建一个对象，然后使用同样的名称（whatever）将方法添加到该对象上，只不过每个重载的函数都是单独的，注意每个重载的参数个数都不相同。通过这种方式，真正为每个重载都创建了一个独立的匿名函数。漂亮且整洁！现在的关键就是实现addMethod()函数，大牛的实现相当巧妙：

function addMethod(object, name, fn) {
　　var old = object[name]; //保存原有的函数，因为调用的时候可能不匹配传入的参数个数
　　object[name] = function() { // 重写了object[name]的方法，是一个匿名函数
　　　　// 如果该匿名函数的形参个数和实参个数匹配，就调用该函数
　　　　if(fn.length === arguments.length) {
　　　　　　return fn.apply(this, arguments);
　　　　// 如果传入的参数不匹配，就调用原有的参数
　　　　} else if(typeof old === "function") {
　　　　　　return old.apply(this, arguments);
　　　　}
　　}
}

 现在，我们一起来分析一个这个addMethod函数，它接收3个参数：

• 第一个为要绑定方法的对象，
• 第二个为绑定方法所用的属性名称，
• 第三个为需要绑定的方法（一个匿名函数）

 好吧，一言不合就举个例子吧

 

《Javascript高级程序设计-第三版》

《JavaScript忍者秘籍》

扩展阅读：