JS设计模式——2.初识接口

什么是接口

接口提供了一种用以说明一个对象应该具有哪些方法的手段。

接口之利

1.接口具有自我描述性从而促进代码的重用

2.接口有助于稳定不同中的类之间的通信方式

3.测试和调试也变得更轻松

接口之弊

1.在一定程度上强化了类型的作用

2.ｊｓ中没有内置的interface，实现它会增加复杂度

3.实现接口会对性能造成一定的影响

4.无法强迫其他程序员遵守你定义的接口

三种方法在JS中模仿接口

注释法（这只是一种文档规范）

/*
interface Composite{
    function add(child);
    function remove(child);
    function getChild(index);
}
interface fromItem{
    function save();
}
*/
var CompositeForm = function(id, method, action){
    ...
};
CompositeForm.prototype.add = function(){
    ...
};
CompositeForm.prototype.remove = function(){
    ...
};
CompositeForm.prototype.getChild = function(){
    ...
};
CompositeForm.prototype.save = function(){
    ...
};

这种方法没有确保对象真正实现了正确的方法集而进行检查，也不会抛出错误以告知程序中有问题。

用属性检查模仿接口

/*
interface Composite{
    function add(child);
    function remove(child);
    function getChild(index);
}
interface fromItem{
    function save();
}
*/
var CompositeForm = function(id, method, action){
    this.implementsInterfaces = ['Composite', 'FormItem']; //声明自己继承的接口
    ...
};
...
function addForm(formInstance){
    if(!implements(formInstance, 'Composite', 'FormItem')){ //检查实例formInstance是否实现了接口
        throw new Error('Object does not implement a required interface');
    }
}
function implements(object){ //检查算法，双重循环
    for(var i=1; i<arguments.length; i++){
        var interfaceName = arguments[i];
        var interfaceFound = false;
        for(var j=0; j<object.implementsInterfaces.length; j++){
            if(object.implementsInterfaces[j] == interfaceName){
                interfaceFound = true;
                break;
            }
        }
        if(!interfaceFound){
            return false;
        }
    }
    return true;
}

这种做法是只知其表不知其里。

用鸭式辨型模仿接口

类是否声明自己支持哪些接口并不重要，只要它具有这些接口中的方法就行。

var Composite = new Interface('Composite', ['add', 'remove', 'getChild']); //声明接口拥有的方法
var FormItem = new Interface('FormItem', ['save']); //声明接口拥有的方法

var compositeForm = function(id, method, action){//implements Composite, FormItem
    ...
};
...
function addForm(formInstance){
    ensureImplements(formInstance, Composite, formItem);
    ...
}

//Constructor
var Interface = function(name, methods){ //将接口的方法保存在this.methods中用以将来的检测
    if(arguments.length != 2){
        throw new Error('Interface constructor called with '+arguments.legth+
            " arguments, but exected exactly 2.");
    }

    this.name = name;
    this.methods = [];
    for(var i=0, len = methods.length; i<len; i++){
        if(typeof methods[i] !== 'string'){
            throw new Error('Interface constructor expects method names to be passed in as a string.');
        }
        this.methods.push(methods[i]);
    }
};
Interface.ensureImplements = function(object){
    if(arguments.length < 2){
        throw new Error('Function Interface.ensureImplements called with'+arguments.length+
            "arugments, but expected at least 2.");
    }
    for (var i=0, len=arugments.length; i<len; i++){
        var intf = arguments[i];
        if(intf.constructor !== Interface){
            throw new Error('Function Interface.ensureImplements expects arguments'+
                "two and above to be instances of Interface.");
        }
        for(var j=0; methodsLen = intf.methods.length; j<methodsLen; j++){ //通过methods检查实例是否实现了接口
            if(!object[method] || typeof object[method]!=='function'){
                throw new Error('Function Interface.ensureImplements:object'+
                    " doesnot implement the"+intf.name+
                    " interface. Method"+method+" was not found!");
            }
        }
    }
};

嗯，这个方法还正规一点。但是要借助其它两个类，也没有声明自己实现哪了些接口，降低了重用性。

一个例子

这个例子确保我们在调用对象的方法时，它已经实现了相应的接口的方法。

var DynamicMap = new Interface('DynamicMap', ['centerOnPoint', 'zoom', 'draw']);
function displayRoute(mapInstance){
    Interface.ensureImplements(mapInstance, DynamicMap);
    mapInstance.centerOnPoint(12,34);
    mapInstance.zoom(5);
    mapInstance.draw();
    ...
}