js 函数的重载

我们知道，很多编程语言都有函数的重载。

所谓的重载，看定义：

重载，简单说，就是函数或者方法有相同的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。

同名函数，根据传入的参数类型不同，来执行对应的方法。

所以从这个定义中，我们能够得出，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 函数同样会递归执行参数个数判断这一过程，这样就实现了根据参数的个数对函数进行重载。