javascript --- 设计模式之单体模式(二)

JavaScript里,实现单例的方式有很多种,其中最简单的一个方式是使用对象字面量的方法,其字面量里可以包含大量的属性和方法:

var her = {
     property1: ‘someing‘,
     property2: ‘someing else‘,
     method1: function(){
          console.log(‘hello, Javascript‘);
     }
}

如果以后要扩展该对象,你可以添加自己的私有成员和方法,然后使用闭包在其内部封装这些变量和函数声明。只暴露你想暴露的public成员和方法,样例代码如下:

var mySingletion = function(){
    /*  这里声明私有变量和方法 */
    var privateVariable  = ‘something private‘;
    function showPrivate(){
        console.log(privateVariable );
    }

    /* 共有变量和方法(可以访问私有变量和方法) */
    return {
        publicMethod: function(){
            showPrivate();
        },
        publicVar: ‘the public can see this‘
    }
}

var single = mySingletion ();
single.publicMethod(); // ‘something private‘
console.log(single.publicVar); //  ‘the public can see this‘ 

上面的代码很不错了,但如果我们想做到只有在使用的时候才初始化,那该如何做呢?为了节约资源的目的,我们可以另外一个构造函数里来初始化这些代码,如下:

var Singleton = (function(){
    var instantiated;
    function init(){
        /* 这里定义单例代码 */
        return {
            publicMethod: function(){
                 console.log(‘Hello, javascript‘);
            },
            publicProperty: ‘test‘
        }
    }

    return {
         getInstance: function(){
              if( !instantiated ){
                    instantiated = init();
              }
              return instantiated ;
         }
    }    

})();
/*  调用共有的方法来获取实例 */
Singleton.getInstance().publicMethod();

知道了单例如何实现了,但单例用在什么样的场景比较好呢?其实单例一般是用在系统间各种模式的通信协调上,下面的代码是一个单例的最佳实践:

var SingletonTester = (function(){
    // 参数:传递给单例的一个参数集合
    function Singleton(args){
        // 设置args变量接受的参数或者为空
        var args = args || {};
        // 设置name参数
        this.name = ‘SingletonTester‘;
        // 设置pointX的值
        this.pointX = age.pointX || 6;
        // 设置pointY的值
        this.pointY = age.pointY || 10;
    }

    // 实例容器
    var instance;

    var _static = {
        name: ‘SingletonTester‘,
        // 获取实例的方法
        // 返回Singleton的实例
        getInstance: function(args){
            if( instance === undefined ){
                  instance  = new Singleton(args);
            }
            return instance;
        }
    }    

    return _static;    

})();

var singletonTest = SingletonTester.getInstance({ pointX: 5 });
console.log(singletonTest.pointX); // 输出5

其他的实现方式:

方法1:

function Universe() {

    // 判断是否存在实例
    if (typeof Universe.instance === ‘object‘) {
        return Universe.instance;
    }

    // 其它内容
    this.start_time = 0;
    this.bang = "Big";

    // 缓存
    Universe.instance = this;

    // 隐式返回this
}

// 测试
var uni = new Universe();
var uni2 = new Universe();
console.log(uni === uni2); // true

方法2:

function Universe() {

    // 缓存的实例
    var instance = this;

    // 其它内容
    this.start_time = 0;
    this.bang = "Big";

    // 重写构造函数
    Universe = function () {
        return instance;
    };
}

// 测试
var uni = new Universe();
var uni2 = new Universe();
uni.bang = "123";
console.log(uni === uni2); // true
console.log(uni2.bang); // 123

方法3:

function Universe() {

    // 缓存实例
    var instance;

    // 重新构造函数
    Universe = function Universe() {
        return instance;
    };

    // 后期处理原型属性
    Universe.prototype = this;

    // 实例
    instance = new Universe();

    // 重设构造函数指针
    instance.constructor = Universe;

    // 其它功能
    instance.start_time = 0;
    instance.bang = "Big";

    return instance;
}

// 测试
var uni = new Universe();
var uni2 = new Universe();
console.log(uni === uni2); // true

// 添加原型属性
Universe.prototype.nothing = true;

var uni = new Universe();

Universe.prototype.everything = true;

var uni2 = new Universe();

console.log(uni.nothing); // true
console.log(uni2.nothing); // true
console.log(uni.everything); // true
console.log(uni2.everything); // true
console.log(uni.constructor === Universe); // true

方法4:

var Universe;

(function () {

    var instance;

    Universe = function Universe() {

        if (instance) {
            return instance;
        }

        instance = this;

        // 其它内容
        this.start_time = 0;
        this.bang = "Big";
    };
} ());

//测试代码
var a = new Universe();
var b = new Universe();
alert(a === b); // true
a.bang = "123";
alert(b.bang); // 123
时间: 2024-11-10 08:19:04

javascript --- 设计模式之单体模式(二)的相关文章

javascript --- 设计模式之单体模式

单体是一个用来划分命名空间并将一些相关的属性与方法组织在一起的对象,如果她可以被实例化的话,那她只能被实例化一次(她只能嫁一次,不能二婚). 单体模式是javascript里面最基本但也是最有用的模式之一. 特点:1. 可以用来划分命名空间,从而清除全局变量所带来的危险或影响. 2. 利用分支技术来来封装浏览器之间的差异.   3. 可以把代码组织的更为一体,便于阅读和维护. 单体模式的基本写法: /* 最基本的单体模式 */ var her = { name: 'Anna', sex: 'wo

javascript设计模式之单体模式

一入前端深似海,刚入前端,以为前端只是div+css布局外加jquery操作DOM树辣么简单.伴随着对前端学习的深入,发现前端也是博大精深,而且懂得越多,才发现自己越无知,所以一定不能停下脚步的学习.原来前端也有设计模式,那么开始了解吧! 今天来学最简单的单体模式,其实就是简单的Object扩展 var calcYourShengXiao={ solar : ["甲","乙","丙","丁","午",&qu

C++设计模式之建造者模式(二)

3.省略指挥者Director的建造者模式 指挥者类Director在建造者模式中扮演非常重要的作用,简单的Director类用于指导具体建造者如何构建产品,它按一定次序调用Builder的buildPartX()方法,控制调用的先后次序,并向客户端返回一个完整的产品对象.Direcotr针对抽象的建造者进行编程,如果需要不同的建造者,只需把建造者传入指挥者类,无需修改之前的代码. 在有些情况下,为了简化系统结构,可以省略指挥者Director,指挥者不再指导产品的创建过程.而是在Builder

浅析JAVA设计模式之工厂模式(二)

1 工厂方法模式简介 工厂方法 (Factroy Method) 模式:又称多态性工厂模式(Polymorphic Factory),在这种模式中,核心工厂不再是一个具体的类,而是一个抽象工厂,提供具体工厂实现的接口,具体创建产品交由子工厂去做,抽象工厂不涉及任何产品被实例化的细节.而不同等级的产品,就对应一个不同等级的工厂,如下图. 图1 1.1工厂方法模式(多态性工厂模式): 工厂方法模式有三个角色: 1. 抽象产品接口 2. 具体产品类 3. 抽象工厂接口 4.具体工厂类. 1.2工厂方法

设计模式之工厂模式 (二)

工厂模式分为三大类 简单工厂(SimpleFactory) 工厂方法模式(Factory Method) 抽象工厂模式(Abstract Factory) 动态工厂(Dynamic Factory,属于优化版简单工厂) 一.简单工厂 组成如下: (1) 工厂类角色:这是本模式的核心,含有一定的商业逻辑和判断逻辑.在java中它往往由一个具体类实现. (2) 抽象产品角色:它一般是具体产品继承的父类或者实现的接口.在java中由接口或者抽象类来实现. (3) 具体产品角色:工厂类所创建的对象就是此

Java经典23种设计模式之创造型模式(二)

本文记录5种创造型模式的剩下两种:建造者模式(Builder).原型模式(PROTOTYPE). 一.建造者模式(别名:生成者模式) 将复杂对象的构建和它的表示分离,使得同样的构建过程可以创建不同的表示.一个完整的建造者模式包含以下几个概念: 1.产品类 Product public class Person { private String head; private String body; private String foot; public String getHead() { ret

【javascript设计模式】构造器模式、模块模式、单例模式

构造器模式(Constructor) 构造器模式是学习js最早接触的一种,实现主要如下: 1 function myObject(name){ 2 this.name = name; 3 } 4 5 myObect.propotype = function sayName(){ 6 alert(this.name); 7 } 使用的时候需要new一个对象. 1 var myObj = new myObject('hello'); 2 myObj.sayName(); 模块模式(Module) 模

javaScript几种设计模式之一——单体模式

javaScript是一种弱类型.动态的.基于原型的语言,这种语言特性使得它非常容易. 甚至是普通的方式实现其中的一些模式. 单体模式的思想在于保证一个特定类仅有一个实例.这就意味着当您第二次使用同一个 类创建新对象的时候,应该得到与第一次所创建对象完全相同对象. 在javaScript中没有类,只有对象.当您创建一个新对象时,实际上没有其他对象与其 类似,因此新对象已经是单体了.使用对象字面量创建一个简单的对象也是一个单体的 例子. var obj ={ myprop:'my value' }

JavaScript设计模式之策略模式(学习笔记)

在网上搜索“为什么MVC不是一种设计模式呢?”其中有解答:MVC其实是三个经典设计模式的演变:观察者模式(Observer).策略模式(Strategy).组合模式(Composite).所以我今天选择学习策略模式. 策略模式:定义了一系列家族算法,并对每一种算法单独封装起来,让算法之间可以相互替换,独立于使用算法的客户. 通常我并不会记得“牛顿第一定律”的具体内容,所以我也难保证我会对这个定义记得多久……用FE经常见到的东西来举个例子说明一下: $("div").animation(