您的位置:新葡亰496net > 奥门新萄京娱乐场 > 新葡亰496net:js高手之路,类方法与设计模式

新葡亰496net:js高手之路,类方法与设计模式

发布时间:2019-10-20 23:34编辑:奥门新萄京娱乐场浏览(69)

      学习设计模式最难的事情就是理解什么样的设计模式适用于什么样的场景。

    一、单例模式

    什么是单例呢?

    1.1静态方法和类方法

      单例模式是一种创建型模式,它会限制应用程序,使其只能创建某以特定类类型的一个单一的实例。

    单例模式是应用开发过程中最简单同时也是最著名的一种创建型设计模式。单例模式提供了一个类只有一个特定类型的对象的机制。

    新葡亰496net,单,就是一个的意思。例:就是实例化出来的对象,那合在一起就是保证一个构造函数只能new出一个实例,为什么要学习单例模式呢?或者说单例模式有哪些常见的应用场景.它的使用还是很广泛,比如:弹出一个模态框,一般来说在网站中弹出的模态框,不停的一直点击,一般只能创建一个。还有后台的数据库连接,一般都是保证一个连接等等。今天的主题就是单例在模态框中的应用,我们先要搞清楚,怎么弄个单例出来.

    1.1.1类方法

    单例模式的实现

      1.我们可以在类中使用一个静态属性,来保证对于一个特定的类来说只存在一个单一的实例。

    class Payment{
        static private $_instance = NULL;
    
    }
    

      

      2.接下来,我们需要在类中创建一个静态方法,在类的实例不存在的时候,此方法将会创建一个这个类的实例,并且返回这个实例。

    static function getInstance(){
        if(self::$_instance == NULL){
            self::$_instance = new Payment();
        }
        return self::$_instance;
    }
    

      通常情况下,单例模式中的这个方法的名字命名为getInstance(),在这个方法中,会有一个条件语句用于检查$_inistance属性是否是一个NULL值。如果是,将会使用new关键字实例化自身,并赋值给这个属性,否则直接返回这个属性。

      

      3.现在这个类可以按照这个方法使用:

    $pay = Payment::getInstance();
    

     

    通常应用于场景为:日志记录、数据库操作等,程序运行时只能生成一个实例,避免对同一资源产生冲突的访问请求。

    我们先看下普通的构造函数加原型方式。下面这种是常见的方式

    是类对象所拥有的方法,需要用修饰器@classmethod(注解、元数据)来标识其为类方法,对于类方法,第一个参数必须是类对象,一般以cls作为第一个参数(当然可以用其他名称的变量作为其第一个参数,但是大部分人都习惯以'cls'作为第一个参数的名字,就最好用'cls'了),能够通过实例对象和类对象去访问。

    单例模式的改进

      如果一个用户试图使用 new 或 clone 去创建这个类的新对象,那么就会得到多个实例,这样就破坏了单例模式的限制。

      防止这种情况发生的一个技巧就是创建一个私有的构造函数:

    private function __construct(){}
    private function __clone(){}
    

      此时,用户尝试使用new去实例化这个类,程序就会产生一个错误。

     

    二、如何设计单例模式

    function Singleton ( uName ){
       this.userName = uName;
       this.ins = null;
      }
      Singleton.prototype.showUserName = function(){
       return this.userName;
      }
      var obj1 = new Singleton( 'ghostwu' );
      var obj2 = new Singleton( 'ghostwu2' );
      console.log( obj1 === obj2 ); //false
    

    新葡亰496net 1

    使用场景举例

      单例模式是在一些限制必须使用单一实例的场景中。例如,一个公司有且只有一个财务中心,公司的所有资金流入流出、财务制度等都由这个财务中心来管理。

      

      

    (1)重写构造函数__new__方法

    每次new都会在内存中生成一块新的内存区域保存新的实例,所以这种方式就不能保证只能new出一个单例,所以,我们想要创建一个单例,就要能够控制new创建实例的过程!!!,这就是单例的关键,那么要控制这个过程,肯定不能让用户直接调用构造函数,所以我们要另外想办法.

    新葡亰496net 2

    class Singleton(object):
        def __new__(self):
            if not hasattr(self,'instance'):
                self.instance = super(Singleton,self).__new__(self)
            return self.instance
    
    
    a = Singleton()
    b = Singleton()
    
    
    print id(a),id(a)
    

    第一种办法: 在函数中添加一个静态方法,来控制创建实例的过程

    运行结果

      该方法主要思路就是在覆盖实例化函数__new__(),在其中添加判断,检查对象是否存在。hasattr是python的特殊方法,用来查看对象是否具有某个属性。

    function Singleton ( uName ){
       this.userName = uName;
      }
      Singleton.prototype.showUserName = function(){
       return this.userName;
      }
      Singleton.getInstance = function( uName ){
       if ( !this.ins ) {
        this.ins = new Singleton( uName );
       }
       return this.ins;
      }
    
      var obj1 = Singleton.getInstance( 'ghostwu' );
      var obj2 = Singleton.getInstance( 'ghostwu2' );
      console.log( obj1 === obj2 ); //true
    

    类方法还有一个用途就是可以对类属性进行修改:

    当然,如果想要继承这个Singleton,子类中一定不要忘了重写__new__方法,否则会覆盖掉父类中已经修改的方法。

    第8行判断ins这个变量是否保存了一个实例,如果没有就new一个,否则直接返回。第二次在调用的时候,由于已经存在了ins,所以直接返回,就不需要在new了,这要就能确保是单例

    新葡亰496net 3

    class Singleton(object):
        def __new__(self):
            if not hasattr(self,'instance'):
                self.instance = super(Singleton,self).__new__(self)
            return self.instance
    
    class test(Singleton):
        def __new__(self):
            super(Singleton,self).__new__(self)
    a = test()
    b = test()
    
    
    print id(a),id(a)
    

    第二种办法:利用闭包和立即表达式的特性

    1.1.1静态方法

      

    function Singleton ( uName ){
       this.userName = uName;
      }
      Singleton.prototype.showUserName = function(){
       return this.userName;
      }
      Singleton.getInstance = (function(){
       var ins = null;
       return function( uName ) {
        if ( !ins ) {
         ins = new Singleton( uName );
        }
        return this;
       }
      })();
    
      var obj1 = Singleton.getInstance( 'ghostwu' );
      var obj2 = Singleton.getInstance( 'ghostwu2' );
      console.log( obj1 === obj2 );
    

    需要通过修饰器@staticmethod来进行修饰,静态方法不需要多定义参数

    (2)元类编程重写__call__方法

    这两种方法都可以,接下来,我就选择第二种方法来实现弹出单一的模态框

    新葡亰496net 4

    元类是一个类的类,可以通过创建元类,重新定义类的行为。当我们用类A创建一个类的时候,python通过A = type( name , bases , dict )创建它,其中name是类的名称,base是基类,dict是属性变量。

    三、传统面向对象方式,每次点击都会弹出新的模态框

    新葡亰496net 5

    下面讨论元类type构造类以及实例的过程:

    样式:

    1、类方法,实例和类对象都能访问

    class Meta(type):
        def __init__(self, name, bases, attrs):
            print "init"
            super(Meta, self).__init__(name, bases, attrs)
        def __new__(meta,name, bases, attrs):
            print "new"
            return super(Meta,meta).__new__(meta,name, bases, attrs)
        def __call__(self):
            print "call"
            return super(Meta,self).__call__()
    
    
    s = ["Student", (object, ), {"name": "Joe", "age": 25}   ]    
    ClassStudent = Meta(*s)
    instance = ClassStudent()
    
    div {
       width: 200px;
       height: 200px;
       border:1px solid #09f;
       box-shadow: 2px 2px 1px #666;
       position: absolute;
      }
    

    cls:类对象

      可以看到,结果是:

    html:

    2、静态方法:不传参,实例和类对象都能访问

    新葡亰496net 6

    <input type="button" value="弹窗">
    

    总结

    这个过程是,首先__new__创建类的实例,作为__init__的输入,完成构造函数的作用。当然这个过程的结果是获得了一个实例并且是叫做:

    js部分:

    从类方法和实例方法以及静态方法的定义形式就可以看出来,类方法的第一个参数是类对象cls,那么通过cls引用的必定是类对象的属性和方法;而实例方法的第一个参数是实例对象self,那么通过self引用的可能是类属性、也有可能是实例属性(这个需要具体分析),不过在存在相同名称的类属性和实例属性的情况下,实例属性优先级更高。静态方法中不需要额外定义参数,因此在静态方法中引用类属性的话,必须通过类对象来引用

    Student的类,ClassStudent是对这个类的引用。当采用()调用,即实现Meta的实例的可调用的实例化过程。

    var oBtn = document.querySelector("input"),
       offset = 20, index = 1;
      function Module( pos ){
       this.offset = pos || 20;
      }
      Module.prototype.create = function(){
       var oDiv = document.createElement( "div" );
       oDiv.style.left = (   index ) * offset   'px';
       oDiv.style.top = (   index ) * offset   'px';
       oDiv.innerHTML = 'ghostwu教你用设计模式实战';
       return oDiv;
      }
      oBtn.onclick = function(){
       var oDiv = new Module();
       document.body.appendChild( oDiv.create() );
      }
    

    1.1设计模式

    至此,我们简单了解了相关的魔术函数的作用。

    新葡亰496net 7

    设计模式(Design pattern)代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

     

    四,用单例改造

    1.1.1设计模式六大原则

    通过元类实现单例模式的方法为:

    html:

    1.设计模式六大原则(1):单一职责原则

    class Meta(type):
        _instance = {}
        def __init__(self, name, bases, attrs):
            print "init"
            super(Meta, self).__init__(name, bases, attrs)
        def __new__(meta,name, bases, attrs):
            print "new"
            return super(Meta,meta).__new__(meta,name, bases, attrs)
        def __call__(self):
            print "call"
    
            if self not in self._instance:
                self._instance[self] = super(Meta,self).__call__()
            return self._instance[self]
    
    
    s = ["Student", (object, ), {"name": "Joe", "age": 25}   ]    
    ClassStudent = Meta(*s)
    instance1 = ClassStudent()
    instance2 = ClassStudent()
    print id(instance1),id(instance2)
    
    <input type="button" value="弹窗1">
    <input type="button" value="弹窗2">
    
    
    var aBtn = document.querySelectorAll("input"),
       offset = 20, index = 1;
      function Module( pos ){
       this.offset = pos || 20;
      }
      Module.prototype.create = function(){
       var oDiv = document.createElement( "div" );
       oDiv.style.left = (   index ) * offset   'px';
       oDiv.style.top = (   index ) * offset   'px';
       oDiv.innerHTML = 'ghostwu教你用设计模式实战';
       return oDiv;
      }
      Module.one = (function(){
       var ins = null, isExist = false;
       return function( pos ){
        if ( !ins ) ins = new Module( pos );
        if ( !isExist ) {
         document.body.appendChild( ins.create() );
         isExist = true;
        }
       }
      })();
      aBtn[0].onclick = function(){
       Module.one( 10 );
      }
      aBtn[1].onclick = function(){
       Module.one( 10 );
      }
    

    即一个类只负责一项职责

      至此,可以看到,通过元类编程实现单例模式,需要改的是__call__函数,因为其构造函数是为了构造类的,而不是在生成实例的过程中,通过函数调用的方式生成实例会调用__call__,因此在这个位置操作。

    在Module.one中通过变量isExist的两种状态和闭包特性控制元素只能被添加一次

    2.设计模式六大原则(2):里氏替换原则

     当然,对于单例类的使用,可以在类中通过__metaclass__属性来设置,取代用type类直接生成的方法。

    以上这篇[js高手之路]单例模式实现模态框的示例就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。

    所有引用基类的地方必须能透明地使用其子类的对象

    class Meta(type):
        _instance = {}
        def __init__(self, name, bases, attrs):
            print "init"
            super(Meta, self).__init__(name, bases, attrs)
        def __new__(meta,name, bases, attrs):
            print "new"
            return super(Meta,meta).__new__(meta,name, bases, attrs)
        def __call__(self):
            print "call"
    
            if self not in self._instance:
                self._instance[self] = super(Meta,self).__call__()
            return self._instance[self]
    
    
    class ClassStudent(object):
        __metaclass__ = Meta
        pass
    
    instance1 = ClassStudent()
    instance2 = ClassStudent()
    print id(instance1),id(instance2)
    

    您可能感兴趣的文章:

    • JS设计模式之单例模式(一)
    • NodeJS设计模式总结【单例模式,适配器模式,装饰模式,观察者模式】
    • JavaScript设计模式之单例模式详解
    • javascript 单例模式详解及简单实例
    • 解析Javascript单例模式概念与实例
    • Javascript单例模式的介绍和实例
    • 轻松掌握JavaScript单例模式
    • JavaScript实现设计模式中的单例模式的一些技巧总结
    • Javascript实现单例模式
    • js单例模式详解实例
    • js单例模式的两种方案
    • JavaScript实现单例模式实例分享

    3.设计模式六大原则(3):依赖倒置原则

      当用户定义一个类class的时候,Python解释器就会在当前类中查找"__metaclass__"属性,如果找到,就通过该属性对应的代码创建类;如果没有找到,就继续以相同的规则查找父类。如果在任何父类中都找不到"__metaclass__",就会用内置的type来创建类对象。

    高层模块不应该依赖低层模块,二者都应该依赖其抽象;抽象不应该依赖细节;细节应该依赖抽象。

    当然对于python3来说,添加了新的声明单例的方法:

    4.设计模式六大原则(4):接口隔离原则

    class Test(metaclass = MyMeta):
        pass
    

    客户端不应该依赖它不需要的接口;一个类对另一个类的依赖应该建立在最小的接口上。

      

    5.设计模式六大原则(5):迪米特法则

    三、Monostate模式

    一个对象应该对其他对象保持最少的了解。尽量降低类与类之间的耦合。

    对于上述单例模式,关注的是生成单一的实例,而通常程序员需要的是让实例共享相同的状态,因此,有时候需要关注状态和行为,而不是同一性。这种概念即为Monostate(单态)模式。python实现这个模式的过程较为轻松:

    6.设计模式六大原则(6):开闭原则

    class ClassStudent(object):
        _age = 20
        pass
    
    instance1 = ClassStudent()
    instance2 = ClassStudent()
    print id(instance1),id(instance2)
    print instance1._age,instance2._age
    

    一个软件实体如类、模块和函数应该对扩展开放,对修改关闭。

      可以看到,虽然不是一个实例,但是状态相同。

    1.1.1分类

     

    1.创建型模式

    主要目的:创建对象

    共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

    2.结构型模式

    主要目的:对象的组成和对象的关系

    共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

    3.行为型模式

    主要目的:对象的行为,对象能做什么

    共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

    1.1工厂设计模式

    设计一个卖车的4S店,该怎样做呢?

    新葡亰496net 8

    新葡亰496net 9

    新葡亰496net 10

    新葡亰496net:js高手之路,类方法与设计模式。总结:

    在创建对象比较简单的时候,我们直接在主方法中做了,但是很多时候,创建对象需要一些初始化的操作,或者业务逻辑的处理。也就是说,有时候创建一个对象会做比较复杂的操作,这个时候,如果所有对象的创建操作都放在主方法中,就不合适了,怎么解决呢?使用简单工厂模式

    简单工厂的优点和缺点

    对象创建比较复杂的时候,可以考虑使用简单工厂

    优点:在简单工厂中

    1.1__new__的使用

    新葡亰496net 11

    新葡亰496net 12

    运行结果

    总结

    ·__new__至少要有一个参数cls,代表要实例化的类,此参数在实例化时由Python解释器自动提供

    ·__new__必须要有返回值,返回实例化出来的实例,这点在自己实现__new__时要特别注意,可以return父类__new__出来的实例,或者直接是object的__new__出来的实例

    ·__init__有一个参数self,就是这个__new__返回的实例,__init__在__new__的基础上可以完成一些其它初始化的动作,__init__不需要返回值

    ·我们可以将类比作制造商,__new__方法就是前期的原材料购买环节,__init__方法就是在有原材料的基础上,加工,初始化商品环节

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:新葡亰496net:js高手之路,类方法与设计模式

    关键词:

上一篇:新葡亰496net动用 StringBuilder

下一篇:没有了