JavaScript实现接口的三种经典方式

/*
接口:提供一种说明一个对象应该有哪些方法的手段
js中有三种方式实现接口:
    1 注释描述接口
    2 属性检测接口
    3 鸭式辨型接口
*/
    
/*
1 注释描述接口： 不推荐
    优点： 利用注解，给出参考
    缺点：纯文档约束，是一个假接口，
        程序不能检查实现接口对象是否实现所有接口方法
*/

/**
 * interface Composite{
 *         function a();
 *         function b();
 * }
 */
// CompositeImpl implements Composite
var CompositeImpl = function(){
    //业务逻辑
};
CompositeImpl.prototype.a = function(){
    //业务逻辑
};
CompositeImpl.prototype.b = function(){
    //业务逻辑
};
    
    
    
    
    
    
    
/*
2 属性检测接口：
    优点：能够检测实现哪些接口
    缺点：没有完全脱离文档，
        不能检测是否实现每个接口里的所有方法
*/
/**
 * interface Composite{
 *         function a();
 * }
 * 
 * interface FormItem(){
 *         function b();
 * }
 */
// CompositeImpl implements Composite,FormItem
var interfacesImpl = function(){
    //在实现类内部用一个数组保存要实现的方法名
    //通常这个属性名是团队中规定好的
    this.implementsInterfaces = ["Composite","FormItem"];
};
CompositeImpl.prototype.a = function(){
    //业务逻辑
};
CompositeImpl.prototype.b = function(){
    //业务逻辑
};

//专门为这个实现对象写一个检测函数，传入实例对象，用于检查实力对象是否实现了所有接口
function checkImplements(obj){
    //调用检查方法 obj是否实现两个接口，如果没有都实现则抛出异常
    if(!isImplements(obj,"Composite","FormItem")){
        throw new Error("接口没有全部实现！");
    }
    //接收一个参数obj是要检查的对象
    function isImplements(obj){
        //arguments对象能够获取实际传入函数的所有参数的数组
        //传入的第0个参数是要检查的对象，所以从1开始检查
        for(var i = 1; i < arguments.length ; i++){
            //接收接口中每个接口的名字
            var interfaceName = arguments[i];
            //一个标记，是否实现这个接口，默认没有
            var foundFlag = false;
            //循环查询传入实例对象的实现接口数组 以检查是否全部实现
            for(var j = 0 ;j <obj.implementsInterfaces.length;j++){
                //如果 实现了这个接口 就修改标记跳出循环
                if(obj.implementsInterfaces[j]==interfaceName){
                    foundFlag = true;
                    break;
                }
            }
            //如果遍历实现接口数组之后没找到 就返回false
            if(!foundFlag){
                return false;
            }
        }
        //如果都找到了 返回true
        return true;
    }
}

//使用实力对象并检测
var o = new interfacesImpl();
checkImplements(o);    //不会抛出异常 因为正确实现了两个接口
//如果在写interfacesImpl内的implementsInterfaces列表的时候少写了，那么就会在检查函数中抛出异常




/*
3 鸭式辨型法：（目前开发中使用的方式）
    实现思想： 

*/

//1 接口类 Class Interface
/**
 * 接口类需要的参数：
 * 1 接口的名字
 * 2 要实现方法名称的数组
 */
var Interface = function( name , methods ){
    //判断参数个数
    if(arguments.length!=2){
        throw new Error("接口构造器参数必须是两个！");
    }
    this.name = name;
    this.methods = [];
    for(var i = 0;i<methods.length;i++){
        if( typeof methods[i] !== "string" ){
            throw new Error("接口实现的函数名称必须是字符串！");
        }
        this.methods.push(methods[i]);    
    }
    
};
//2 准备工作：
// 2.1 实例化接口对象    传入接口名 和 要实现的方法数组
var CompositeInterface = new Interface("CompositeInterface",["add","remove"]);
var FormItemInterface = new Interface("FormItemInterface",["update","select"]);

//  2.2 实现接口的类
//CompositeImpl implementes CompositeInterface ,FormItemInterface
var CompositeImpl = function(){
    
};
//  2.3 实现接口的方法
CompositeImpl.prototype.add = function(obj){
    alert("add...");
};
CompositeImpl.prototype.remove = function(obj){
    alert("remove...");
};
CompositeImpl.prototype.select = function(obj){
    alert("select...");
};
//在这里少实现一个方法 下面检测是否全部实现了接口方法
// CompositeImpl.prototype.update = function(obj){
    // alert("update...");
// };
// 实例化   实现接口的对象
var c = new CompositeImpl();

//3 检验接口里的方法是否全部实现
// 如果检验通过 继续执行;如果不通过抛出异常;
Interface.ensureImplements = function(obj){
    // 如果接收到参数小于2 说明 传参出错了，只传入一个参数，，没有传入实现的接口
    if(arguments.length<2){
        throw new Error("接口检查方法的参数必须多余两个！");
    }
    //获得要见测的接口实现对象之后的参数 各个接口
    for(var i = 1,len = arguments.length;i<len;i++){
        var instanceInterface = arguments[i];    //获取当前这个接口
        //判断接收到的是不是接口的对象  如果不是 抛出异常
        if( instanceInterface.constructor !== Interface){
            throw new Error("接口检测函数必须传入接口对象！");
        }
        //检查实例化接口的对象是不是实现了接口里的所有方法
        // 当前接口对象里的每一个方法
        for(var j = 0 ; j<instanceInterface.methods.length;j++){
            var methodName = instanceInterface.methods[j]; //接收到了字符串的方法名
            //如果obj里面没有有methodName这个方法 或者有这个属性但是不是函数 就抛出异常
            if(!obj[methodName] || typeof obj[methodName] !== "function"){
                throw new Error("接口方法"+ methodName +"没有实现！");
            }
        }
    }
    
    
};
//传入要检查的类，和他要实现的所有接口对象
Interface.ensureImplements(c ,CompositeInterface ,FormItemInterface );
c.add();