精华内容
下载资源
问答
  • js建造者模式

    2017-03-21 15:22:00
    建造者模式:可以将一个复杂对象的构建与其表示相分离,使得同样的构建过程可以创建不同的表示。也就是说如果我们用了建造者模式,那么用户就需要指定需要建造的类型就可以得到他们,而具体建造的过程和细节就不需要...

    建造者模式:可以将一个复杂对象的构建与其表示相分离,使得同样的构建过程可以创建不同的表示。也就是说如果我们用了建造者模式,那么用户就需要指定需要建造的类型就可以得到他们,而具体建造的过程和细节就不需要知道了。建造者模式实际,就是一个指挥者,一个建造者,一个使用指挥者调用具体建造的工作得出结果的客户。

         建造者模式主要用于“分步骤构建一个复杂的对象”,在这其中“分步骤”是一个稳定的算法,而复杂对象的各个部分则经常变化。

    //白富美发送一个请求 要建房子
    //包工头接受这个请求,并招募工人建房
    //工人完成建造房子的人

    //1.产出的是房子
    //2.baogongtou调用工人进行开工,而且他要清除工人们具体的某一个大项
    //3.工人是盖房子 工人可以建卧室、客厅、厨房
    //4.包工头只是一个接口,他不干活,他对外说我能建房子
    function Fangzi(){
    this.woshi='';
    this.keting='';
    this.chufang='';
    }
    function Baogongtou(){
    this.jianfangzi=function(gongren){
    gongren.jian_woshi();
    gongren.jian_keting();
    gongren.jian_chufang();
    }
    }
    function Gongren(){
    this.jian_woshi=function(){
    console.log('卧室已经建好了');
    }
    this.jian_keting=function(){
    console.log('客厅已经建好了');
    }
    this.jian_chufang=function(){
    console.log('厨房已经建好了');
    }
    this.jiaogong=function(){
    var _fangzi=new Fangzi();

    _fangzi.woshi='ok';
    _fangzi.keting='ok';
    _fangzi.chufang='ok';
    return _fangzi;
    }
    }
    var gongren=new Gongren;
    var baogongtou=new Baogongtou;
    baogongtou.jianfangzi(gongren);
    var myfangzi=gongren.jiaogong();
    console.log(myfangzi);

    作用:
    1.分布创建一个复杂的对象。
    2.解耦封装过程和具体创建的组件。
    3.无需关心组件如何组装。
    注意事项:
    1.一定要一个稳定的算法进行支持。
    2.加工工艺是暴露的。

     

    转载于:https://www.cnblogs.com/sungangmo/p/6594525.html

    展开全文
  • JS建造者模式

    2019-10-02 01:32:32
    function getBeerById( id, callback){ _request('GET','URL'+id,function(res){ callback(res.responseText) }); }; function getBeerByIdBridge(){ ...
        function getBeerById( id, callback){
            _request('GET','URL'+id,function(res){
                callback(res.responseText)
            });
        };
    
        function getBeerByIdBridge(){
            getBeerById(id,function(res){
                alert(res.toString());
            });
            //doAnothering;
        };
    
        var el = document.querySelector('#test');
        el.addEventListener('click',getBeerByIdBrige,false);

    所谓的建造者模式跟桥接模式一样好像,就是常见的回调,让思路更加清晰一点点

    转载于:https://www.cnblogs.com/diligenceday/p/3429896.html

    展开全文
  • JS 建造者模式

    2017-12-14 08:15:42
    1. 简介 在软件系统中,有时候面临着“一个复杂对象”的创建工作,其通常由各个部分的子对象用一定的算法构成;由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法确相对稳定...
        

    1. 简介

    在软件系统中,有时候面临着“一个复杂对象”的创建工作,其通常由各个部分的子对象用一定的算法构成;由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法确相对稳定。如何应对这种变化?如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化,从而保持系统中的“稳定构建算法”不随着需求改变而改变?这就是要说的建造者模式。

    建造者模式(Builder pattern),将一个复杂对象的构建层与其表示层相互分离,使得同样的构建过程可以采用不同的表示。也就是说如果我们用了建造者模式,那么用户就需要指定需要建造的类型就可以得到它们,而具体建造的过程和细节就不需要知道了。

    在工厂模式中,对创建的结果都是一个完整的个体,我们对参见的过程不为所知,只了解创建的结果对象。而在建造者模式中我们关心的是对象的创建过程,因此我们通常将创建对象的类模块化,这样使被创建的类的每一个模块都可以得到灵活的运用和高质量的复用。

    2. 实现

    const Human = function(param) {
      this.skill = param && param.skill || '保密'
      this.hobby = param && param.hobby || '保密'
    }
    Human.prototype = {
      getSkill: function() {
        return this.skill
      },
      getHobby: function() {
        return this.hobby
      }
    }
    
    const Named = function(named) { 
      (function(named, that) {
        that.wholeName = named
        if (named.includes(' ')) {
          that.FirstName = named.slice(0, named.indexOf(' '))
          that.SecondeName = named.slice(named.indexOf(' '))
        }
      })(named, this)
    }
    
    const Work = function(work) {
      (function(work, that) {
        switch (work) {
          case 'code':
            that.work = '工程师'
            that.workDesc = '每天沉迷于编程'
            break
          case 'UE':
            that.work = '设计师'
            that.workDesc = '设计更像一种艺术'
            break
          default :
            that.work = work
            that.workDesc = '对不起,我们不清楚您所选择职位的描述'
        }
      })(work, this)
    }
    
    Work.prototype.changeWork = function(work) {
      this.work = work
    }
    
    const Person = function(param, name, work) {    // 构造方法,不同模块使用不同创建过程
      const _person = new Human(param)
      _person.named = new Named(name)
      _person.work = new Work(work)
      return _person
    }
    
    const xiaoming = new Person({ skill: '耍帅', hobby: '装逼' }, 'xiao ming', 'code')
    xiaoming.skill    // 耍帅
    xiaoming.FirstName  // xiao
    xiaoming.work    // 工程师

    根据建造者的定义,表相即是回调,也就是说获取数据以后如何显示和处理取决于回调函数,相应地回调函数在处理数据的时候不需要关注是如何获取数据的,同样的例子也可以在jquery的ajax方法里看到,有很多回调函数(比如success, error回调等),主要目的就是职责分离。

    同样再来一个jQuery的例子:$('<div class= "foo"> bar </div>'),我们只需要传入要生成的HTML字符,而不需要关心具体的HTML对象是如何生产的。

    3. 总结

    建造者模式主要用于“分步骤构建一个复杂的对象”,在这其中“分步骤”是一个稳定的算法,而复杂对象的各个部分则经常变化,其优点是:建造者模式的“加工工艺”是暴露的,这样使得建造者模式更加灵活,并且建造者模式解耦了组装过程和创建具体部件,使得我们不用去关心每个部件是如何组装的。

    这种方式对于整体对象类的拆分无疑增加了结构的复杂性,因此如果对象粒度很小,或者模块间的复用率很低并且变动不大,我们最好还是要创建整体对象。


    本文是系列文章,可以相互参考印证,共同进步~

    1. JS 抽象工厂模式
    2. JS 工厂模式
    3. JS 建造者模式
    4. JS 原型模式
    5. JS 单例模式
    6. JS 回调模式
    7. JS 外观模式
    8. JS 适配器模式
    9. JS 利用高阶函数实现函数缓存(备忘模式)
    10. JS 状态模式
    11. JS 桥接模式
    12. JS 观察者模式

    网上的帖子大多深浅不一,甚至有些前后矛盾,在下的文章都是学习过程中的总结,如果发现错误,欢迎留言指出~

    参考:
    设计模式之建造者模式
    《Javascript 设计模式》 - 张荣铭
    展开全文
  • js 建造者模式

    2017-08-30 19:45:02
    将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。 var shirt = function(params){ this.color = params && params.color || '无色'; this.size = params && params.size || 'big';...

    将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。

    var shirt = function(params){
        this.color = params && params.color || '无色';
        this.size = params && params.size || 'big';
    }
    shirt.prototype = {
        wear : function(){
            console.log('Wear '+this.size+' and '+this.color+' shirt')
        },
        undress : function(){
            console.log('Undress '+this.size+' and '+this.color+' shirt')
        }
    }
    //衬衫类
    
    var pants = function(params){
        this.color = params && params.color || '无色';
        this.size = params && params.size || 'big';
    }
    pants.prototype = {
        wear : function(){
            console.log('Wear '+this.size+' and '+this.color+' pants')
        },
        undress : function(){
            console.log('Undress '+this.size+' and '+this.color+' pants')
        }
    }
    //裤子类
    
    var human = function(params,shirtParams,pantsParams){
        this.name = params && params.name || 'Peter';
        this.age = params && params.age || 18;
        this.shirt = new shirt(shirtParams);
        this.pants = new pants(pantsParams);
    }
    
    human.prototype = {
        sayHello : function(){
            console.log('Hello I am '+this.name);
        },
        sayAge : function(){
            console.log('Hello I am '+this.age);
        }
    }
    //人类
    
    
    var peter = new human();
    peter.sayHello();
    peter.shirt.wear();
    
    var jack = new human({name:'jack',age:30},{color:'red',size:'small'},{color:'yello',size:'small'})
    jack.sayAge();
    jack.pants.undress();
    
    
    展开全文
  • 主要介绍了JS建造者模式基本用法,以一个完整实例形式较为详细的分析了javascript建造者模式的实现方法,需要的朋友可以参考下
  • JS设计模式之建造者模式
  • 下面一起来看下建造者模式//建造者--施工团队 let builder = function () { //成员01--决定厅室 function Rooms(member) { if (member <= 0) { throw new Error("入住人数错误"); ...
  • 建造者模式:将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示。 主要解决:在软件系统中,有时候面临着"一个复杂对象"的创建工作,由于需求的变化,这个复杂对象的某些部分经常面临着剧烈的...
  • 模式作用: 1,分步创建一个复杂的对象 2,解耦封装过程和具体...建造者模式可以理解为:各司其职,拆解流程 包工头->工人->房子 --> //发生一个请求 白富美 //建造者模式 包工头 //完整的工程 工人 // 1
  • 建造者模式:将一个复杂对象的构建层与其表示层相互分离,同样的构建过程可以采用不同的表示。主要用于分步骤构建一个负责的对象,在这其中“分步骤”是一个稳定的算法,而复杂对象的各个部分则经常变化。下面我们...
  • 1、建造者模式 建造者:将一个复杂的构建层与其表示层相互分离,同样的构建过程可采用不同的表示。 其实就是将一个复杂的对象分解成多个简单的对象来进行构建,不仅仅关注于创建的结果,更关注于创建的细节。 特点...
  • 关于创建型模式,已经接近尾声了,还剩下建造者模式和原型模式,这一篇说一说建造者模式 建造者模式的定义 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。 很官方哈,举个例子,就...
  • js建造者(生成器)模式

    2017-03-23 16:01:00
    建造者模式将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。 在软件系统中,有时需要创建一个复杂对象,并且这个复杂对象由其各部分子对象通过一定的步骤组合而成。 建造者模式类图:...
  • 将一个复杂对象的构建层和表示层相分离,同样的构建过程...然而建造者模式在创建对象的过程中则更为复杂一些。虽然目的也是为了创建对象,但是更关心的创建对象的整个过程或者说是每一个细节。 var Human = funct...
  • 1 <!DOCTYPE html> 2 <html lang="en"> 3 <head> 4 <meta charset="UTF-8"> 5 <title>functionModule</title> 6 </head> 7 <body>... ...
  • 建造者模式 将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示。主要解决在软件系统中,有时候面临着"一个复杂对象"的创建工作,由于需求的变化,这个复杂对象的某些部分经常面临着剧烈的变化...
  • 设计模式(4)[JS版]-JavaScript如何实现建造者模式

    千次阅读 多人点赞 2020-07-21 20:59:56
    1什么是建造者模式 2 建造者模式的作用和注意事项 3.代码实现 4总结 1什么是建造者模式 建造者模式(Builder)可以将一个复杂对象的构建与其表示相分离,使得同样的构建过程可以创建不同的表示。也就是说如果...
  • 建造者模式:将一个复杂对象的构建层与其表示层相互分离,同样的构建过程可采用不同的表示。 工厂模式主要是为了创建对象实例或者类簇,关心的是最终产出的是什么。不关心你创建的整个过程,仅仅需要知道最终创建的...
  • 参考文章:java设计模式之建造者模式 一、什么是建造者模式建造者模式:是将一个复杂的对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。工厂类模式提供的是创建单个类的模式,而建造者模式则是将...

空空如也

空空如也

1 2 3
收藏数 53
精华内容 21
热门标签
关键字:

js建造者模式