《javascript设计模式》-2-接口

/**

 * 接口是一种指定对象应该有哪些方法的技术，他不关心方法如何实现。

 * 基于接口编程的好处是：实现相同接口的对象，可以互换，而不影响功能实现。

 * 接口还有利于大项目中，多人合作的交流

 */

/**************** 在js中模仿接口 ******************/



//用注释描述接口

//效果最差，不会提供错误信息

//易于实现

/*

 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) {



};

Composite.prototype.getChild = function (index) {



};



//implement the formItem interface

CompositeForm.prototype.save = function () {



};





//用属性检查模仿接口

/*

 优点：

 对类所实现的接口提供了文档说明

 如果没有必须的接口会提示错误消息

 缺点：

 显示声明类所支持的接口，但没有真正检测接口是否存在

 */

/*

 interface COMposite {

 function add(child);

 function remove(child);

 function getChild(index);

 }

 interface FormItem {

 function save();

 }

 */

var CompositeForm = function (id, method, action) {

    //add interface into array

    this.implementsInterfaces = ['Composite', 'FormItem'];

    //...

};



function addForm(formInstance) {

    if (!implements(formInstance, 'Composite', 'formItem')) {

        throw new Error('Object does not implement a required interface.');

    }

    //...

}



//The implement function,which checks to see if an object declares that

//it implements the required interface

function implements(object) {

    //looping through all arguments after the first one

    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) {

            //an interface was not found

            return false;

        }

    }

    //all interface were found

    return true;

}





//用鸭式辩型模仿接口

//如果对象具有与接口定义的方法同名的所有方法

//那么就可以认为它实现了这个接口

/**

 * 三种方法中最有用的一种

 * 缺点：

 *     类并不声明自己实现了那些接口，降低了代码的可重用性

 *     缺乏自我描述

 *     不检查方法的参数

 */

//Interface.

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

    //...

}





//本书采用的接口实现方法

//结合第一种和第三种方法

//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) {

    Interface.ensureImplements(formInstance, Composite, FormItem);

    //this function will throw an error if a required method is not implemented

    //halting execution of the function

    //all code beneath this line will be executed only if the checks pass

    //...

}





/************ Interface类 *************/

//Constructor

var Interface = function (name, method) {

    // 检测参数个数

    if (arguments.length != 2) {

        throw new Error('Interface constructor called with ' + arguments.length + 'arguments,ut expected exactly 2.');

    }

    this.name = name;

    this.methods = [];

    //遍历方法

    for (var i = 0, len = method.length; i < len; i++) {

        //检查数组值是否字符串

        //如果不是，抛出错误信息

        if (typeof method[i] !== 'string') {

            throw new Error('Interface constructor expects method names to be passed in as a string');

        }

        //将方法名添加到属性数组中

        this.methods.push(method[i]);

    }



};



//static class method

Interface.ensureImplements = function (object) {

    //参数个数必须大于等于2个

    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];

        //如果不是Interface的实例，则抛出错误

        if (interface.constructor !== Interface) {

            throw new Error('Function interface.ensureImplements expectes 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];

            //如果object没有实例中的方法，则抛出错误

            if (!object[method] || typeof object[method] !== 'function') {

                throw new Error('Function Interface.ensureImplements:object does not implement the ' + interface.name + 'interface. Method ' + method + ' was not found.');

            }

        }

    }

};





//使用

    var DynamicMap = new Interface('DybamicMap', ['centerOnPoint', 'zoom', 'draw']);



    function displayRoute(mapInstance) {

        Interface.ensureImplements(mapInstance, DynamicMap);

        mapInstance.centerOnPoint(12, 34);

        mapInstance.zoom(5);

        mapInstance.draw();

        //...

    }

    var Test = function () {



    };

    Test.prototype = {

        centerOnPoint:function (a, b) {

            console.log('centerOnPoint2');

        },

        zoom:function (num) {

            console.log('zoom2');

        },

        draw:function(){



        }

    };

    var a = new Test();

    displayRoute(a);





//实例

// ResultFormatter class,before we implement interface checking

//未使用Interface类检测

var TestResult = function () {



};

TestResult.prototype = {

    getDate:function () {



    },

    getResults:function () {



    }

};

var ResultFormatter = function (resultsObject) {

    // 是否为TestResult的实例

    // 不是就抛出错误

    if (!(resultsObject instanceof TestResult)) {

        throw new Error('ResultsFormatter: constructor requires an instance of TestResult as an argument.');

    }

    //将参数公有化

    this.resultsObject = resultsObject;

};



ResultFormatter.prototype.renderResults = function () {

    var dateOfTest = this.resultsObject.getDate();

    var resultsArray = this.resultsObject.getResults();



    var resultsContainer = document.createElement('div');

    var resultsHeader = document.createElement('h3');

    resultsHeader.innerHTML = 'Test Results from ' + dateOfTest.toUTCString();

    resultsContainer.appendChild(resultsHeader);



    var resultsList = document.createElement('ul');

    resultsContainer.appendChild(resultsList);

    for (var i = 0, len = resultsArray.length; i < len; i++) {

        var listItem = document.createElement('li');

        listItem.innerHTML = resultsArray[i];

        resultsList.appendChild(listItem);

    }



    //返回创建的DOM

    return resultsContainer;

};

/*

 TestResult类可能被修改，致使其不再拥有getDate()方法

 检查仍能通过，但renderResults方法却会失灵

 不允许其他类的实例作为参数

 */



//使用Interface类后

//ResultSet interface

var ResultSet = new Interface('ResultSet', ['getDate', 'getResults']);



//ResultFormatter class, after adding Interface checking

var ResultFormatter = function (resultsObject) {

    Interface.ensureImplements(resultsObject, ResultSet);

    this.resultsObject = resultsObject;

};



ResultFormatter.prototype.renderResults=function(){

    //...

};