精华内容
下载资源
问答
  • 什么是单例模式 定义:1.只有一个实例。...js单例模式优点:1、在内存里只有一个实例,减少了内存的开销,尤其是频繁的创建和销毁实例(比如管理首页页面缓存)。 2、避免对资源的多重占用(比如写文...

    什么是单例模式

    定义:1.只有一个实例。2.可以全局访问

    主要解决:一个全局使用的类频繁地创建与销毁。

    js单例模式何时使用:当您想控制实例数目,节省系统资源的时候。

    如何解决:判断系统是否已经有这个单例,如果有则返回,如果没有则创建。

    js单例模式优点: 1、在内存里只有一个实例,减少了内存的开销,尤其是频繁的创建和销毁实例(比如管理首页页面缓存)。 2、避免对资源的多重占用(比如写文件操作)。

    单例模式缺点:没有接口,不能继承,与单一职责原则冲突,一个类应该只关心内部逻辑,而不关心外面怎么样来实例化。

    js单例模式使用场景: 1.全局缓存。2.弹窗

    实现js单例模式:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    const singleton = function(name) {

        this.name = name

        this.instance = null

    }

     

    singleton.prototype.getName = function() {

        console.log(this.name)

    }

     

    singleton.getInstance = function(name) {

        if (!this.instance) { // 关键语句

            this.instance = new singleton(name)

        }

        return this.instance

    }

     

    // test

    const a = singleton.getInstance('a') // 通过 getInstance 来获取实例

    const b = singleton.getInstance('b')

    console.log(a === b)

    JavaScript 中的单例模式

    因为 JavaScript 是无类的语言,而且 JS 中的全局对象符合单例模式两个条件。很多时候我们把全局对象当成单例模式来使用

    1

    var obj = {}

    弹框层的实践

    实现弹框的一种做法是先创建好弹框,然后使之隐藏,这样子的话会浪费部分不必要的 DOM 开销,我们可以在需要弹框的时候再进行创建,同时结合单例模式实现只有一个实例,从而节省部分 DOM 开销。下列为登入框部分代码:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    //弹框层的实践

    const createLoginLayer = function() {

        const myDiv = document.createElement('div')

        myDiv.innerHTML = '登入浮框'

        // myDiv.style.display = 'none'

        document.body.appendChild(myDiv);

        return myDiv

    }

     

    //使单例模式和创建弹框代码解耦

    const getSingle = function(fn) {

      let result = null;

      return function() {

          if(!result){

              result = fn.apply(this, arguments);

          }

        return result;

      }

    }

     

    const createSingleLoginLayer = getSingle(createLoginLayer)

     

    document.getElementById('loginBtn').onclick = function() {

        createSingleLoginLayer()

    }

    展开全文
  • js设计模式--单例模式

    2019-01-02 14:56:23
    js设计模式--单例模式 js设计模式--策略模式 js设计模式--代理模式 概念 单例模式的定义是:保证一个类仅有一个实例,并提供一个访问它的全局访问点。 UML类图 场景 单例模式是一种常用的模式,...
        

    前言

    本系列文章主要根据《JavaScript设计模式与开发实践》整理而来,其中会加入了一些自己的思考。希望对大家有所帮助。

    文章系列

    js设计模式--单例模式

    js设计模式--策略模式

    js设计模式--代理模式

    概念

    单例模式的定义是:保证一个类仅有一个实例,并提供一个访问它的全局访问点。

    UML类图

    clipboard.png

    场景

    单例模式是一种常用的模式,有一些对象我们往往只需要一个,比如线程池、全局缓存、浏 览器中的 window 对象等。

    在 JavaScript 开发中,单例模式的用途同样非常广泛。试想一下,当我们单击登录按钮的时候,页面中会出现一个登录浮窗,而这个登录浮窗是唯一的,无论单击多少 次登录按钮,这个浮窗都只会被创建一次,那么这个登录浮窗就适合用单例模式来创建。

    优缺点

    优点:创建对象和管理单例的职责被分布在两个不同的方法中

    实现

    1. 我们的第一个单例

    
    var instance = null
    var getInstance = function(arg) {
      if (!instance) {
        instance = arg
      }
      return instance
    }
    
    var a = getInstance('a')
    var b = getInstance('b')
    console.log(a===b)

    这种定义一个全局变量的方式非常不优雅,也不好复用代码

    2. 利用闭包实现单例

    
    var Singleton = function( name ){
      this.name = name;
    };
    
    Singleton.getInstance = (function(){
      var instance = null;
      return function( name ){
        if ( !instance ){
          instance = new Singleton( name );
        }
        return instance;
      }
    })();
    var a = Singleton.getInstance('a')
    var b = Singleton.getInstance('b')
    console.log(a===b)

    有些同学可能对闭包不大理解,下面用函数实现一下

    3. 利用函数实现单例

    
    function Singleton(name) {
      this.name = name
      this.instance = null
    }
    
    Singleton.getInstance = function(name) {
      if (!this.instance) {
        this.instance = new Singleton(name)
      }
      return this.instance
    }
    
    var a = Singleton.getInstance('a')
    var b = Singleton.getInstance('b')
    console.log(a===b)
    

    2,3这两种方式也有缺点,就是我们必须调用getInstance来创建对象,一般我们创建对象都是利用new操作符

    4. 透明的单例模式

    var Singleton = (function() {
      var instance
      Singleton = function(name) {
        if (instance) return instance
        this.name = name
        return instance = this
      }
      return Singleton
    })()
    
    var a = new Singleton('a')
    var b = new Singleton('b')
    console.log(a===b)
    

    这中方法也有点缺点:不符合单一职责原则,这个对象其实负责了两个功能:单例和创建对象

    下面我们分离这两个职责

    5. 利用代理实现单例

    var People = function(name) {
      this.name = name
    }
    
    var Singleton = (function() {
      var instance
      Singleton = function(name) {
        if (instance) return instance
        return instance = new People(name)
      }
      return Singleton
    })()
    
    var a = new Singleton('a')
    var b = new Singleton('b')
    console.log(a===b)
    

    这中方法也有点缺点:代码不能复用。如果我们有另外一个对象也要利用单例模式,那我们不得不写重复的代码

    6. 提供通用的单例

    
    var People = function(name) {
      this.name = name
    }
    
    var Singleton = function(Obj) {
      var instance
      Singleton = function() {
        if (instance) return instance
        return instance = new Obj(arguments)
      }
      return Singleton
    }
    
    var peopleSingleton = Singleton(People)
    
    var a = new peopleSingleton('a')
    var b = new peopleSingleton('b')
    console.log(a===b)

    到这里已经比较完美了,等等这只是es5的写法,下面我们用es6来实现一下

    7. es6单例模式

    class People {
        constructor(name) {
            if (typeof People.instance === 'object') {
                return People.instance;
            }
            People.instance = this;
            this.name = name
            return this;
        }
    }
    var a = new People('a')
    var b = new People('b')
    console.log(a===b)

    比较以上几种实现

    1. 用全局变量的第1种方法,应该摒弃
    2. 用闭包实现的第2种方式,instance 实例对象总是在我们调用 Singleton.getInstance 的时候才被创建,应该摒弃
    3. 其他方式都是惰性单例(在需要时才创建)

    js的特殊性

    我们都知道:JavaScript 其实是一门无类(class-free)语言,,生搬单例模式的概念并无意义。

    单例模式的核心是确保只有一个实例,并提供全局访问。

    我们可以用一下几种方式来另类实现

    1. 全局变量

    比如var a = {},这时全局就只有一个a对象
    但全局变量存在很多问题,它很容易造成命名空间污染,我们用以下两种方式解决

    2.使用命名空间

      var namespace1 = {
        a: function () {
          alert(1);
        },
        b: function () {
          alert(2);
        }
      };

    另外我们还可以动态创建命名空间

    
      var MyApp = {};
      MyApp.namespace = function (name) {
        var parts = name.split('.');
        var current = MyApp;
        for (var i in parts) {
          if (!current[parts[i]]) {
            current[parts[i]] = {};
          }
          current = current[parts[i]];
        }
      };
      MyApp.namespace('event');
      MyApp.namespace('dom.style');
      console.dir(MyApp);
      // 上述代码等价于:
      var MyApp = {
        event: {},
        dom: {
          style: {}
        }
      };

    3. 闭包

      var user = (function () {
        var __name = 'sven',
          __age = 29;
        return {
          getUserInfo: function () {
            return __name + '-' + __age;
          }
        }
      })();

    例子

    登录框

    下面我们来实现一个点击登录按钮弹出登录框的例子

    粗糙的实现

    <html>
    
    <body>
      <button id="loginBtn">登录</button>
    </body>
    <script>
      var loginLayer = (function () {
        var div = document.createElement('div');
        div.innerHTML = '我是登录浮窗';
        div.style.display = 'none';
        document.body.appendChild(div);
        return div;
      })();
      document.getElementById('loginBtn').onclick = function () {
    
        loginLayer.style.display = 'block';
      };
    </script>
    
    </html>
    

    上面这种方式如果用户没有点击登录按钮,也会在一开始就创建登录框

    改进

    
    <html>
    
    <body>
      <button id="loginBtn">登录</button>
    </body>
    <script>
      var createLoginLayer = function () {
        var div = document.createElement('div');
        div.innerHTML = '我是登录浮窗';
        div.style.display = 'none';
        document.body.appendChild(div);
        return div;
      };
      document.getElementById('loginBtn').onclick = function () {
        var loginLayer = createLoginLayer();
        loginLayer.style.display = 'block';
      };
    </script>
    
    </html>

    这种方式每次点击按钮都会创建一个登录框

    再改进

    
    var createLoginLayer = (function () {
        var div;
        return function () {
          if (!div) {
            div = document.createElement('div');
            div.innerHTML = '我是登录浮窗';
            div.style.display = 'none';
            document.body.appendChild(div);
          }
          return div;
        }
      })();
    
      document.getElementById('loginBtn').onclick = function () {
        var loginLayer = createLoginLayer();
        loginLayer.style.display = 'block';
      };

    这种方式不够通用,不符合单一职责原则

    再再改进

    
      var getSingle = function (fn) {
        var result;
        return function () {
          return result || (result = fn.apply(this, arguments));
        }
      };
    
      var createLoginLayer = function () {
        var div = document.createElement('div');
        div.innerHTML = '我是登录浮窗';
        div.style.display = 'none';
        document.body.appendChild(div);
        return div;
      };
      var createSingleLoginLayer = getSingle(createLoginLayer);
      document.getElementById('loginBtn').onclick = function () {
        var loginLayer = createSingleLoginLayer();
        loginLayer.style.display = 'block';
      };
    
      //下面我们再试试创建唯一的iframe 用于动态加载第三方页面:
      var createSingleIframe = getSingle(function () {
        var iframe = document.createElement('iframe');
        document.body.appendChild(iframe);
        return iframe;
      });
      document.getElementById('loginBtn').onclick = function () {
        var loginLayer = createSingleIframe();
        loginLayer.src = 'http://baidu.com';
      };
    

    至此已经完美

    展开全文
  • js单例模式

    2019-12-18 14:47:39
    如果懂得如何巧妙的使用那就更棒啦~~今天来介绍什么是单例模式单例模式:保证一个类仅有一个实例,并提供一个访问它的全局访问点。 单例模式–1、对象字面量创建的对象;使用命名空间创建实例。 单例模式–2、...

    单例模式:保证一个类仅有一个实例,并提供一个访问它的全局访问点。实现方法一般是先判断实例是否存在,如果存在直接返回,如果不存在就先创建再返回。
    1、对象字面量创建的对象

    //字面量创建对象,适当的使用字面量创建对象,可以减少全局变量的数量。
    var Myapp={
    	a:function(){
    		console.log('b');
    	}
    };
    

    对象字面量创建对象适当使用可以减少全局变量的数量,但是利用对象字面量创建对象时属性和方法都是暴露的,不存在私有变量。
    2、使用闭包封装私有变量;这种方式把变量封装到闭包的内部,只暴露一些接口跟外界通信。

    //利用闭包封装私有变量,可以避免对全局对象的污染。
    var Myapp=(function(){
    			var _count=0;		//外部访问不到这个变量
    			return {				//暴露对象给外部访问
    				getNum:function(){
    					return _count++;
    				},
    				a:function(){
    					console.log('b');
    				}
    			}
    		}());
    

    eg:点击一个按钮创建一个DOM元素。
    每点击一次创建一个DOM元素,然而这样做不好,浪费性能。
    点击创建,在创建之前先判断是否存在这个DOM,若不存在则创建,并用一个变量将这个创建的DOM保存起来,下次想在用的时候,直接拿第一次创建的不就好了嘛。

    		// 用函数来创建单例模式=>立调函数,返回一个函数
    		// 这个函数将创建div并且判断是否已经创建对象。
    		var createDiv=(function(){
    			var div;		//保存上次的div记录,私有变量
    			return function(){
    				if(!div){
    					div =document.createElement('div');
    					div.innerHTML='我是登入的div';
    					// div.style.display='none';
    					document.body.appendChild(div);
    				}
    				return div;
    			}
    		})()
    		document.getElementById('loginBtn').onclick=function(){
    			var div=createDiv();
    			// div.style.display='block';
    		}
    

    通过的惰性单例模式:惰性这词还挺抽象的,如何理解呢?惰性单例的意思可以理解成:需要的时候才创建对象。

    // 创建单例对象
    		var getSingle=function(fn){
    			var result;
    			return function(){
    				return result||(result=fn.apply(this,arguments))
    			}
    		}
    

    如上的代码就是封装了一个通用的惰性单例模式,fn可以是你即将要创建的函数,比如你要创建一个模态框,对话框,div,iframe等之类的函数。
    应用场景:
    1、任务管理器
    2、回收站
    3、登入注册Dom生成模块的弹框。

    展开全文
  • 单例模式JS设计模式之单例模式设计模式前言起源首先要说明的是设计模式期初并非软件工程中的概念,而是起源于建筑领域。建筑学大师(克里斯托夫·亚历山大)曾经花了很长时间(传闻说20年)研究为了解决同一问题而采用的...

    单例模式

    JS设计模式之单例模式

    设计模式前言

    起源

    首先要说明的是设计模式期初并非软件工程中的概念,而是起源于建筑领域。建筑学大师(克里斯托夫·亚历山大)曾经花了很长时间(传闻说20年)研究为了解决同一问题而采用的不同的建筑结构,在这些结构当中有很多优秀的设计,而在这些设计当中又有很多相似性,因此他用“模式”来描述这种相似性。并写了一本书《模式语言》。对整个建筑领域产生了很深远的影响。

    2b6c0180acf92f9e530230b8432ebb61.png
    59737d726c0373c4bcddd94ea97990ff.png

    而在编程领域,类似的情况会更加的多。微软杰出工程师(艾瑞克·伽玛)受到克里斯托夫·亚历山大和他的《模式语言》的启发,把这种模式的概念移植到了软件开发中,并且针对C++提出了23种设计模式,写成了《设计模式:可复用面向对象软件的基础》一书。

    定义

    原文定义:在面向对象的程序设计中,针对特定问题的简洁和优雅解决方案。

    解释:给解决方案取个好听的名字

    作用

    • 一定会增加代码量
    • 一定会增加复杂度
    • 有可能提升可维护性
    • 有可能降低沟通成本

    JS中的设计模式

    并不是所有的设计模式都适用于任何开发语言,每种语言因为本身的设计初衷就不相同,有些设计模式在C语言里非常适用,但是在JS里有更简单的解决方案,在这种情况下就没有必要一定按照设计模式中的描述通过强制模拟的方式来实现。比如我们常说JS中函数是一等公民,可以当做对象来使用,也可以当做参数来传递,还可以当成类来使用,而这些特性在很多静态类型语言中需要用特定的方式来实现,因此在JS中很多模式是解释器本身就实现的,不需要做额外的工作。

    如何理解和使用设计模式

    首先应该了解各种设计模式解决的问题,当你在开发的过程中遇到问题的时候,除了常规的解决方案之外,可以有更多的选择,当你去开发一个框架或者开发一套架构的时候能够考虑到更多的情况,并且设计出更容易拓展,更好维护的结构。

    学习设计模式的前提

    • 深入的了解函数 作用域 闭包
    • 熟练应用this call bind apply
    • 熟练使用高级函数(纯函数 高阶函数 记忆函数 偏函数....)
    • 掌握函数式变成的思想以及理解其使用的意义

    单例模式

    普通构造函数

    单例模式是指一个构造函数,无论new多少次,返回的都是同一个实例,比如alert,在我们使用的时候页面上只会有一个alert弹窗。 先来看一个普通的构造函数

    function Test(){}let a=new Test;let b=new Test;console.log(a===b)//false

    通过函数属性构造单例

    如果我们希望a,b是完全相等的应该怎样做?

    可以在构造函数上增加一个instance属性来保存实例,并增加一个getInstance方法来获取实例。如果实例存在则直接返回,如果不存在则创建一个保存在instance属性中并返回。

    function Single(){}Single.getInstance=function(){ if(!this.instance){ this.instance=new Single(); } return this.instance};let a=Single.getInstance();let b=Single.getInstance();console.log(a===b);//true

    这样做虽然解决的问题,但是又造成了两个新的问题

    • 第一:没有对参数进行处理
    • 第二:并不是是用new方法来创建的实例,和常规操作不符。

    解决传参问题

    先来解决第一个问题,参数的处理

    function Alert(content){ this.content=content;}Alert.getInstance=function(content){ if(!this.instance){ this.instance=new Alert(content); }else{ this.apply(this.instance,arguments) } return this.instance};Alert.prototype.showContent=function(){ console.log(this.content)}let a=Alert.getInstance('this is a');a.showContent();//this is alet b=Alert.getInstance('this is b');b.showContent();//this is bconsole.log(a===b);//true

    通过new操作符实现单例构造

    这样就解决了传参的问题,接下来我们来解决是用new操作符的问题。由于要通过变量对生成的实例进行保存,又不能污染全局环境,所以这里我们使用IFFE来执行,并返回构造函数。

    let Alert=(function(){ let instance; function Alert(content){ if(!instance){ instance=this; } instance.init(content); return instance; } Alert.prototype.init=function(content){ this.content=content; }; return Alert;})();let a=new Alert('this is a');a.showContent();//this is alet b=new Alert('this is b');b.showContent();//this is bconsole.log(a===b);//true

    省略new操作符

    至此基础的单例就完成了,但还远远没有结束,在我们使用一些基础对象的时候,如数组,我们可以使用New Array的方式,也可以不使用new操作符 直接使用Array也是可以的,因此我们对函数进行改造;

    let Alert=(function(){ let instance; function Alert(content){ if(this instanceof Alert){ if(!instance){ instance=this; } }else{ if(!instance){ instance=new Alert(content); } } instance.init(content); return instance; } Alert.prototype.init=function(content){ this.content=content; }; return Alert;})();let a=Alert('a');console.log(a.content);//alet b=Alert('b');console.log(b.content)//bconsole.log(a===b);//true

    对上面的代码进行一下优化

    let Alert=(function(){ let instance; function Alert(content){ instance=instance||( this instanceof Alert?this:new Alert(content) ) instance.init(content); return instance; } Alert.prototype.init=function(content){ this.content=content; }; return Alert;})();

    前文说到设计模式是基于C++提出的,而每种语言又有自己的独特性,比如JS中“一切皆对象”,而对象本身就是一种单例,任何对象只要指针不同就不相等,我们前面做的仅仅是通过一个独立的变量来保存结果并返回,借助ES6的import export可实现的更加简单,也不会涉及到全局污染,如此看来似乎并不能体现出单例的优势,所以下面我们来说单例模式中最重要的概念----惰性单例

    惰性单例

    上面的案例只是一个理论上的DEMO,在实际的开发中并没有太大的用途,接下来我们来看一下单例模式最核心的应用,惰性单例。 我们平时如果只做弹窗,一定是自己通过DOM节点来模拟一个弹窗,所以必然涉及到DOM操作,也就是在上面的代码中的init函数中去创建DOM元素,但是这样操作就会导致每次创建实例的时候都创建一次DOM节点,这显然是不正确的,因此,我们可以把DOM的创建过程提到函数顶部,也就是程序一开始直接创建一个DOM节点,仅在init中去修改里面的内容。

    let Alert=(function(){ let instance=null; let dom=document.createElement('div'); dom.style.display='none'; document.body.appendChild(dom); function Alert(content){ instance=instance||( this instanceof Alert?this:new Alert(content) ) instance.init(content); return instance; } Alert.prototype.init=function(content){ dom.style.display='block'; dom.innerText=content; }; Alert.prototype.hide=function(content){ dom.style.display='none' }; return Alert;})();let a=new Alert('this is a');

    虽然功能都实现了,但是在页面打开之后就在网页中建立的DOM节点,造成不必要的浪费,其实我们完全可以在生成alert实例的时候再去生成这些dom节点,因此我们可以再次使用单例将创建DOM节点的操作制作成一个单例。

    let Alert=(function(){ let instance=null; let dom; function creatDom(){ if(!dom){ dom=document.createElement('div'); dom.style.display='none'; document.body.appendChild(dom); } return dom; } function Alert(content){ instance=instance||( this instanceof Alert?this:new Alert(content) ) instance.init(content); return instance; } Alert.prototype.init=function(content){ creatDom(); dom.style.display='block'; dom.innerText=content; }; Alert.prototype.hide=function(content){ dom.style.display='none' }; return Alert;})();let a=new Alert('this is a');

    现在功能都完成了,但还是存在一些问题,creatDom操作违背了设计模式中的“单一职责”原则,这个函数应该只负责创建节点,以便在其他地方复用,我们更希望creatDom的操作是这样的。

    function creatDom(){ let dom=document.createElement('div'); dom.style.display='none'; document.body.appendChild(dom); return dom; }

    因此我们可以将单例的逻辑提取出来,制作成高阶单例函数,当我们需要创建单例的时候直接调用这个函数就可以了,这里我们将creatDom作为参数传递给getSingle来使用,这种方式也被称为通用惰性单例。

    通用惰性单例

    let getSingle=(function(){ let single; return function(fn){ return single||(single=fn.apply(this,arguments)) }})();function creatDom(){ let dom=document.createElement('div'); dom.style.display='none'; document.body.appendChild(dom); return dom;}let Alert=(function(){ let instance=null; let dom; function Alert(content){ instance=instance||( this instanceof Alert?this:new Alert(content) ) instance.init(content); return instance; } Alert.prototype.init=function(content){ dom=getSingle(creatDom); dom.style.display='block'; dom.innerText=content; }; Alert.prototype.hide=function(content){ dom.style.display='none' }; return Alert;})();

    你可以将上面的这个代码块的内容粘贴到控制台,然后运行以下测试代码查看效果

    let a=Alert('123')//页面上插入一个DIV内容为123let b=new Alert('345')//123变成456b.hide()//div隐藏
    展开全文
  • 主要介绍了JS模式之单例模式基本用法,实例分析了javascript单例模式的基本实现方法,需要的朋友可以参考下
  • js单例模式详解实例

    2020-10-26 15:35:09
    主要介绍了什么是单例单例模式、使用场景,提供了3个示例给大家参考
  • JS单例模式

    2020-03-09 20:02:31
    单例模式 把判断单例的逻辑封装在 getSingle函数内部,创建对象的方法 fn 被当成参数动态传入 getSingle 函数:(想要获得特定的元素只需要传入对应的fn就可以了,而无需改变getSinglel函数) var getSingle = ...
  • JS 单例模式

    2017-12-14 02:22:08
    1. 单例模式 单例模式 (Singleton) 的实现在于保证一个特定类只有一个实例,第二次使用同一个类创建新对象的时候,应该得到与第一次创建对象完全相同的对象。当创建一个新对象时,实际上没有其他对象与其类似,因为...
  • JavaScript 设计模式之js中的单例模式

    万次阅读 2019-11-25 22:07:22
    javascript是一门无类语言,也正是因为如此,生搬硬套单例模式的概念毫无意义。在Javascript中创建对象的方法非常简单,既然我们只需要一个唯一的“对象”,为什么要为它先创建一个“类呢”? 单例模式的核心是:...
  • 转:单例模式

    2019-05-09 09:03:00
    JS设计模式一:单例模式 设计模式——单例模式 1. 概念 下面是维基百科对单例模式的介绍: 单例模式,也叫单子模式,是一种常用的软件设计模式。 在应用这个模式时,单例对象的类必须保证只有一个实例存在。 ...
  • 要说js设计模式那几种最常见,首先首先可能就会说出 是单例模式 单例模式::只允许 实例化一次的对象类。 这个 可能我们经常再用 只是不知道他是 单例模式 比如 1.封装的一个小型的工具对象 var pop={ getDom:...
  • JS设计模式 - 单例模式 最近在看设计模式,首先了解的是单例模式。在网上看了一博客,但是感觉自己没有找到想要抓住的点。所以自己记录一些在学习看的过程中的一些想法。 1. 简介 单例模式说的是只能被实例...
  • js 单例模式

    2018-04-09 16:12:44
    js 单例模式 顾名思义: 只能生成一个 实例对象 &lt;!DOCTYPE html&gt; &lt;html lang="en"&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,062
精华内容 424
关键字:

单例模式js