javascript设计模式--接口

   最近在看javascript设计模式的书籍《pro javascript design pattrens》，觉得很不错，可以提高自己对js oo的理解，也可能帮助自己更好的理解别人写的js library，提高自己js的水平。
        这本书中第一个重要的内容就是接口。
        大家对接口应该都不陌生，简单的说接口就是一个契约或者规范。在强类型的面相对象语言中，接口可以很容易的实现。但是在javascript中并没有原生的创建或者实现接口的方式，或者判定一个类型是否实现了某个接口，我们只能利用js的灵活性的特点，模拟接口。

        在javascript中实现接口有三种方式：注释描述、属性验证、鸭子模型。
note：因为我看的是英文书，翻译水平有限，不知道有些词汇如何翻译，大家只能领会精神了。

1. 注释描述（Describing Interfaces with Comments）
例子：
/*
interface Composite {
    function add(child);
    function remove(child);
    function getChild(index);
}
interface FormItem {
    function save();
}
*/
var CompositeForm = function(id, method, action) { // implements Composite, FormItem
    ...
};
// Implement the Composite interface.
CompositeForm.prototype.add = function(child) {
    ...
};
CompositeForm.prototype.remove = function(child) {
    ...
};
CompositeForm.prototype.getChild = function(index) {
    ...
};
// Implement the FormItem interface.
CompositeForm.prototype.save = function() {
    ...
};

        模拟其他面向对象语言，使用interface 和 implements关键字，但是需要将他们注释起来，这样就不会有语法错误。
        这样做的目的，只是为了告诉其他编程人员，这些类需要实现什么方法，需要在编程的时候加以注意。但是没有提供一种验证方式，这些类是否正确实现了这些接口中的方法，这种方式就是一种文档化的作法。

2. 属性验证（Emulating Interfaces with Attribute Checking）

例子：
/*
interface Composite {
    function add(child);
    function remove(child);
    function getChild(index);
}
interface FormItem {
    function save();
}
*/
var CompositeForm = function(id, method, action) {
    this.implementsInterfaces = ['Composite', 'FormItem'];
    ...
};
...
function addForm(formInstance) {
    if(!implements(formInstance, 'Composite', 'FormItem')) {
        throw new Error("Object does not implement a required interface.");
    }
    ...
}

// The implements function, which checks to see if an object declares that it
// implements the required interfaces.
function implements(object) {
    for(var i = 1; i < arguments.length; i++) { // Looping through all arguments
        // after the first one.
        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; // An interface was not found.
        }
    }

    return true; // All interfaces were found.
}

        这种方式比第一种方式有所改进，接口的定义仍然以注释的方式实现，但是添加了验证方法，判断一个类型是否实现了某个接口。

3.鸭子类型（Emulating Interfaces with Duck Typing）
// Interfaces.
var Composite = new Interface('Composite', ['add', 'remove', 'getChild']);
var FormItem = new Interface('FormItem', ['save']);
// CompositeForm class
var CompositeForm = function(id, method, action) {
    ...
};
...
function addForm(formInstance) {
    ensureImplements(formInstance, Composite, FormItem);
    // This function will throw an error if a required method is not implemented.
    ...
}

// Constructor.
var Interface = function(name, methods) {
    if(arguments.length != 2) {
        throw new Error("Interface constructor called with " + arguments.length +"arguments, but expected 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]);
    }
};

// Static class method.
Interface.ensureImplements = function(object) {
    if(arguments.length < 2) {
        throw new Error("Function Interface.ensureImplements called with " +arguments.length + "arguments, but expected at least 2.");
    }

for(var i = 1, len = arguments.length; i < len; i++) {
var interface = arguments[i];

        if(interface.constructor !== Interface) {
            throw new Error("Function Interface.ensureImplements expects arguments"+ "two and above to be instances of Interface.");
        }

        for(var j = 0, methodsLen = interface.methods.length; j < methodsLen; j++) {
            var method = interface.methods[j];
            if(!object[method] || typeof object[method] !== 'function') {
                throw new Error("Function Interface.ensureImplements: object "
                    + "does not implement the " + interface.name
                &

补充：web前端 , JavaScript ,