我们知道，很多编程语言都有函数的重载。
所谓的重载，看定义：
重载，简单说，就是函数或者方法有相同的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。
同名函数，根据传入的参数类型不同，来执行对应的方法。
所以从这个定义中，我们能够得出，js 并不具备函数的重载功能。
因为 js 不用对传入的参数的类型，进行严格的定义。所以，即使我们写了同名的函数，也只会导致后面的函数会将前面的函数覆盖掉。
现在我们假设，即使 js 同名函数能够共存，但是我们无法知道不同的同名函数分别接收什么类型的参数，同样无法判断该调用哪一个方法。
但是我们在平时写代码的过程中，有一种情况是比较常见的。
比如，我们现在有一个对象 People，有私有属性 name 和 age。
因为 JavaScript 中没有私有属性，所以我们只能通过闭包来模拟私有属性。
所以，我们在构造函数内部定义 name 和 age 对象，通过 get，set 接口来统一读取和修改他们。
代码见下面所示。
var People = function(n, a){
let name = n;
let age = a;
let self = this;
if(!(self instanceof People)){
return new People(n, a);
}
self.get = function(type){
if(type === 'name'){
return name;
}
if(type === 'age'){
return age;
}
}
self.set = function(type, value){
var flag = false;
if(type === 'name' && typeof value === 'string'){
name = value;
flag = true;
}
if(type === 'age' && typeof value === 'number'){
age = value;
flag = true;
}
return flag;
}
return self;
}
用的时候，我们可以这样：
// 防止构造函数中没用 new 我们检测了一下 this 的指向
var a = People('Ted', 19); // undefined
a.get('name'); //"Ted"
a.set('name'); //false
a.set('name', 'Jay'); //true
a.get('name'); //"Jay"
a.set('age'); //false
a.get('age'); //19
a.set('age', 34); //true
a.get('age'); //34
可以看到，这里，我们通过用了 get 和 set 函数，来对外提供接口。
那么，我们想一想，我们能不能将这两个函数合并一下，通过同一个函数，来实现这两种功能呢？
答案当然是肯定的，我么可以改写一下我们之前的构造函数：
var People = function(n, a){
let name = n;
let age = a;
let self = this;
if(!(self instanceof People)){
return new People(n, a);
}
var get = function(type){
if(type === 'name'){
return name;
}
if(type === 'age'){
return age;
}
}
var set = function(type, value){
var flag = false;
if(type === 'name' && typeof value === 'string'){
name = value;
flag = true;
}
if(type === 'age' && typeof value === 'number'){
age = value;
flag = true;
}
return flag;
}
self.o = function(){
if(arguments.length === 1){
return get.apply(this, arguments);
}else if(arguments.length === 2){
return set.apply(this, arguments);
}
}
return self;
}
再看下我们的使用过程：
var a = People('Ted', 19) //undefined
a.o('name'); //"Ted"
a.o('name', "jay"); //true
a.o('name'); //"jay"
可以看出来，这样一改，这个接口调用起来就很方便了。
虽然乍一看，这样该写了以后，好像不太好理解。但是如果习惯了这种写法以后，你会感受到这种写法的奇妙之处。简直太方便了，传一个参数就是拿值，传两个参数，就是改写对应的值。
当然这种写法，是我们在架构我们的项目的时候，有这种意识，这当然算是一种比较好的写法了。
但是如果我们刚开始架构的时候，是这样写的：
var People = function(n, a){
let self = this;
if(!(self instanceof People)){
return new People(n, a);
}
this._name = n;
this._age = a;
return self;
}
随着我们项目的进行，可能在原型链上，有很多方法都用到了 this._name 或者 this._age。
这个时候，如果想要迁移我们的变量成闭包内部的变量，当然是不划算的，改写起来太麻烦了。
但是如果我们又想要提供一个类似于之前的 o 函数，该怎么做呢？
也许又童鞋得第一反应是，这还不简单，三下五除二的进行了如下的拓展：
People.prototype.o = function(){
var get = function(type){
if(this[`_${type}`]){
return this[`_${type}`];
}
}
var set = function(type, value){
var flag = false;
if(type === 'name' && typeof value === 'string'){
this[`_${type}`] = value;
flag = true;
}
if(type === 'age' && typeof value === 'number'){
this[`_${type}`] = value;
flag = true;
}
return flag;
}
if(arguments.length === 1){
return get.apply(this, arguments);
}else if(arguments.length === 2){
return set.apply(this, arguments);
}
}
这样写固然没有问题，但是还是不太具备扩展性。
如果，某一天，我们突发奇想，想要拓展一下这个 o 方法，当不传参数的时候，我们想要列出实例上所有的属性。
我们固然可以通过重载这个 o 方法来实现，但是总感觉不够优雅。
现在有一种更为优雅的方式。
我们可以创建一个 overload 方法用于重载：
function overload(obj, name, func){
var old = obj[name];
obj[name] = function(){
if(func.length === arguments.length){
return func.apply(this, arguments);
}else if(typeof old === 'function'){
return old.apply(this, arguments);
}
}
}
我们可以这样调用：
overload(a, 'o', function(){
return Object.keys(this).reduce((cur, key) => {
if(typeof this[key] !== 'function') cur.push(key);
return cur;
}, []);
});
a.o(); //["_name", "_age"]
我们还可以继续扩展：
overload(a, 'o', function(type1, type2, str){
console.log(this[`_${type1}`], this[`_${type2}`], str);
});
a.o('name', 'age', 'Happy birthday!'); //Ted 19 Happy birthday!
可以看出来，我们的重载函数，非常的强大，扩展性也是非常的强。
可以对任意一个对象上的函数进行重载，当然这里是通过识别参数的个数来进行重载的，这也是现阶段 js 中所能做到的极限了。
这个小小的 overload 方法，同样也是通过闭包来实现的重载。
原理就是通过比较函数的参数与传入的参数个数是否相等，相等则用调用当前函数进行执行。如果不相等，那么调用 old 函数，进行执行。而 old 函数同样会递归执行参数个数判断这一过程，这样就实现了根据参数的个数对函数进行重载。
