Javascript设计模式

面向对象

动态语言： Javascript 是动态语言，即编译时不会对变量类型进行检查只有到了运行时才动态生成变量。
接口：实例 - 鸭子类型。两个类型之间有相同的接口即认为是相同的
多态：

原则“不变的隔离，变化的封装” 鸭子实例中 sound()接口是相同的，但是不同的动物有不同的sound实现，因此发声是变化的需隔离、不同动物的实现是变化的需封装在不同的对象中。不同的对象就是多态。多态对外的表现就是把不变的暴露给其它对象。
Javascript类型检查：
1. 静态语言严格的类型检查，因此只能通过对象之间的继承来实现类型的一致性。实例 - 鸭子、鸡都能发生它们共同继承动物类。调用发声时传递的是动物这个超类因此保证了类型的一致。　　
2. 动态语言天然多态，不对类型进行检查，所以只要类型之间有相同的接口就可

封装。静态语言依靠private, protected等方式实现封装；javascript没有这些机制。靠变量作用域来实现封装。实例: 使用闭包实现变量的私有化、访问的公有化

define(function (require, exports, module) {
    var classObj = (
        function () {
            var _env;
            var setEnv = function (name) {
                _env = name;
            };
            var getEnv = function () {
                return _env;
            };

            return {
                setEnv: setEnv,
                getEnv: getEnv
            }
        }
    )();

    module.exports = classObj;
});

单例模式:

简单单例 -

   var div = function (name) {
        this.instance =null;
        this.name = name;
    };

    div.prototype.getName= function () {
        alert(this.name);
    }

    div.getSingle = function () {
        if(!this.instance) {
            this.instance = new div();
        }
        return this.instance;
    };
　　　// Main方法
    $scope.testMethod = function () {
        var c = div.getSingle();
        var d = div.getSingle();
        alert(c==d);
    };

以上单例用户使用时需要知道getSingle方法是为了单例而设计的方法。现在实现一种透明单例

透明代理

var div = (function () {
        var instance = null;
        var createDiv = function (html) {
            if(instance) return instance;
            this.html = html;
            this.init();
            instance = this;
            return instance;
        };

        createDiv.prototype.init = function () {
            var div = document.createElement('div');
            div.innerHTML=this.html;
            document.body.appendChild(div);
        };
        return createDiv;
    })();
    $scope.testMethod = function () {
　　　　　// 使用 New的方式 使用 单例 
        var c = new div('ab c');

        var d = new div('12 3');
        alert(c == d);
    };

改进版的透明代理，构造函数即负责init有负责实例。职责非单一而且复用性差，使用代理的方式改进

var div = (function () {
        var createDiv = function (html) {
            this.html = html;
            this.init();
        };

        createDiv.prototype.init = function () {
            var div = document.createElement('div');
            div.innerHTML = this.html;
            document.body.appendChild(div);
        };
        return createDiv;
    })();

    var divProxy = (function () {
        var instance=null;
        return function (html) {
            if(instance) return instance;
            instance = new div(html);
            return instance;
        }
    })();
    $scope.testMethod = function () {
        var c = new divProxy('ab c');

        var d = new divProxy('12 3');
        alert(c == d);
    };

策略模式

策略模式指的是定义一系列的算法，把他们封装起来。算法使用是在一个统一的Context中。

 var stratogyA= function () {
    };
    stratogyA.prototype.getSalary = function (salary) {
        return salary*2;
    };

    var stratogyB= function () {
    };
    stratogyA.prototype.getSalary = function (salary) {
        return salary*3;
    };


    var context = function (stratogy) {

        this.strategy=stratogy;
    };
    context.prototype.calculateSalary= function (orgin) {
        return this.strategy.getSalary(orgin);
    };

    $scope.testMethod = function () {
        var str = new stratogyA();

        var c = new context(str);
        var l = c.calculateSalary(1000);
        alert(l);

    };