国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

學習這些設計模式,讓你寫出更優(yōu)雅的代碼

songjz / 367人閱讀

摘要:寫代碼容易,寫出優(yōu)雅的代碼難,寫易于維護的容易擴展的結構清晰的代碼應該是每位開發(fā)者努力的目標,而學習設計模式,合理的的使用能讓我們離這個目標更進一步。

寫代碼容易,寫出優(yōu)雅的代碼難,寫易于維護的、容易擴展的、結構清晰的代碼應該是每位開發(fā)者努力的目標,而學習設計模式,合理的的使用能讓我們離這個目標更進一步。最近看了《Javascript設計模式與開發(fā)實踐》這本書,一言以蔽之,真不錯的一本書,在這里總結一下書中介紹的主要的在JavaScript中我們可以用到的一些設計模式。設計模式的思想是值得反復咀嚼、思考的,在以后的業(yè)務實現(xiàn)中,應該結合這些思想,加以合理的使用

更多內容

單例模式
單例模式保證類只有一個實例,并提供一個訪問它的全局訪問點

js中實現(xiàn)

  function getSingle(fn){
    let result

    return function (){
        return result || (result=fn.apply(this,arguments))
    }

  }
策略模式
解決一個問題的多個方法,將每種方法獨立封裝起來,相互可以替換

一個基于策略模式的程序至少由兩部分組成,一個是一組策略類,策略類封裝了具體的算法,并負責具體的計算過程,一個是環(huán)境類,環(huán)境類接受客戶的請求,隨后把請求委托給某個策略類

策略模式的一個使用場景:表單驗證,將不同驗證規(guī)則封裝成一組策略,避免了多重條件判斷語句

一句經典的話:在函數作為一等對象的語言中,策略模式是隱性的,策略就是值為函數的變量

例子:

    const S = (salary)=>{
        return salary * 4
    }
    const A = (salary)=>{
        return salary * 3
    }
    const B = (salary)=>{
        return salary * 2
    }

    const calculate = (fun,salary)=>{
        return fun(salary)
    }
    calculate(S,1000)
代理模式
代理模式為一個對象提供一個代用品或占位符,以便控制對它的訪問

不直接和本體進行交互,而是在中間加入一層代理,代理來處理一些不需要本體做的操作

var myImage=function(){
    var imgNode=document.createElement("img")
    document.body.appendChild(imgNode)
    return {
        setImg(src){
            imgNode.src=src
        }
    }
}

var proxyImg=function(){
    var img =new Image()
    img.onload=function(){
        myImage.setSrc(this.src)
    }
    return {
        setImg(src){
            myImage.setSrc(‘loading.png’)
            img.src=src      
        }
    }
}

代理的意義

對單一職責原則的一種表現(xiàn),單一職責原則指的是,一個函數或類應該只負責一件事,如何一個函數職責太多,等于把這些職責耦合在了一起,當一部分需要改動時,很有可能就影響到了函數的其他部分

觀察者和發(fā)布訂閱模式

觀察者和發(fā)布、訂閱模式使程序的兩部分不必緊密耦合在一起,而是通過通知的方式來通信

觀察者模式

一個對象維持一系列依賴于它的對象,當對象狀態(tài)發(fā)生改變時主動通知這些依賴對象

這里注意是對象直接管理著依賴列表,這點也是觀察者模式和發(fā)布、訂閱模式的主要區(qū)別

class Subject{
        constructor(){
            this.observers=[]
        }
        add(observer){
            this.observers.push(observer)
        }
        notify(data){
            for(let observer of this.observers){
                observer.update(data)
            }
        }
    }

    class Observer{
        update(){

        }
    }

觀察者模式的缺點是對象必須自己維護一個觀察者列表,當對象狀態(tài)有更新時,直接調用其他對象的方法,所以,在使用中,我們一般采用一種變形方式,即發(fā)布訂閱模式

發(fā)布訂閱模式

該模式在主題和觀察者之間加入一層管道,使得主題和觀察者不直接交互,發(fā)布者將內容發(fā)布到管道,訂閱者訂閱管道里的內容,目的是避免訂閱者和發(fā)布者之間產生依賴關系

    class Pubsub{

        constuctor(){
            this.pubsub={}
            this.subId=-1
        }

        publish(topic,data){
            if(!this.pubsub[topic]) return
            const subs=this.pubsub[topic]
            const len=subs.length
            while(len--){
                subs[len].update(topic,data)
            }
        }

        /**
        *  topic {string}
        *  update {function}
        */
        subscribe(topic,update){
            !this.pubsub[topic] && (this.pubsub[topic]=[])
            this.subId++
            this.pubsub[topic].push({
                token:this.subId,
                update
            })
        }

        unsubscribe(token){
            for(let topic in this.pubsub){
                if(this.pubsub.hasOwnProperty(topic)){
                    const current=this.pubsub[topic]
                    for(let i=0,j=current.length;i

發(fā)布訂閱模式是在框架設計中經常使用的一種設計模式,angularjs中的自定義事件,Rxjs,狀態(tài)管理的redux等都能看到它的身影

命令模式
命令模式的命令指的是一個執(zhí)行某些特定事情的指令

命令模式最常見的使用場景是:有時候需要向某些對象發(fā)送請求,但是不知道請求的接受者是誰,也不知道被請求的操作是什么。此時希望用一種松耦合的方式來設計程序,是使得請求發(fā)送者和接受者消除彼此之間的耦合關系

命令模式的由來,其實是回調函數的一個面向對象的替代品

一句話來說,命令模式就是用一個函數來包裹一個具體的實現(xiàn),這個函數統(tǒng)一定義了一個execute方法來調用具體的實現(xiàn)方法,而請求者只要和這個命令函數交流就行

享元模式
享元模式顧名思義,共享一些單元,用于優(yōu)化重復、緩慢及數據共享效率較低的代碼

應用:一是用于數據層,處理內存中保存的大量相似對象的共享數據,二是用于DOM層,事件代理

在享元模式中,有個有關兩個狀態(tài)的概念-內部和外部

內部狀態(tài)存儲于對象內部,可以被一些對象共享,獨立于具體的場景,通常不會變

外部狀態(tài)根據場景而變化

剝離了外部狀態(tài)的對象成為共享對象,外部狀態(tài)在必要時被傳入共享對象來組成一個完整的對象

使用享元模式的幾個步驟:

以書中文件上傳的例子描述

剝離外部狀態(tài)

 class Upload{

    constructor(type){
        this.uploadType=type
    }

    delFile(id){
        uploadManager.setExternalState(id,this) //這里就是組裝外部狀態(tài)來使共享對象變成一個具體的對象
        if(this.fileSize<3000){
            //直接刪除
            return
        }
        //彈窗詢問確認刪除?
    }

 }

使用工廠進行對象實例化

    var UploadFactory=(function(){
        const flyWeightObjs={}
        return {
            create(uploadType){
                if(flyWeightObjs[uploadType]){
                    return flyWeightObjs[uploadType]
                }
                return flyWeightObjs[uploadType]=new Upload(uoloadType)
            }
        }
    })()

使用管理器封裝外部狀態(tài)

var uploadManager=(function(){
    var uploadDatabase={}
    return {
        add(id,uploadType,fileSize,fileName){
            var flyWeightObj=UploadFactory.create(uploadType) //那個被共享的對象
            //創(chuàng)建結點...
            //刪除操作
            dom.onclick=function(){
                flyWeightObj.delFile(id) //這個共享在步驟1中會被組合,可以看到,只有在刪除操作的時候,我們才需要那些外部狀態(tài)
            }
            uploadDatabase[id]={
                fileName,
                fileSize,
                dom
            }
            return flyWeightObj
        },
        setExternalState(id,flyWeight){
            var externalState=uploadDatabase[id]
            Object.assign(flyWeight,externalState)
        }
    }
})()
責任鏈模式
將一個請求以此傳遞給多個函數,若請求符合當前函數要求,則當前函數處理,否則,傳給下一個

很好很強大

責任鏈模式可以很好的避免大量的if,else if,else

if (Function.prototype.chainAfter) {
    throw new Error("the chainAfter method already exist")
} else {
    Function.prototype.chainAfter = function (fn) {
        return (...args) => {
            const ret = this.apply(this, [...args, () => {
                return fn && fn.apply(this, args)
            }])
            if (ret === "NEXT") {
                return fn && fn.apply(this, args)
            }
            return ret
        }
    }
}

/**
 * example
 * class Test{
 *  
 *     test(...args){
 *            alert("test")
 *            return "NEXT"
 *     }
 * 
 *     test1(...args){
 * 
 *            setTimeout(()=>{
 *                  alert("test1")
 *                  args.pop()()
 *            })   
 *     }
 * 
 *     test2(...args){
 *            alert("test2")
 *     }
 * 
 *      $onInit(){
 *          const chain = this.test.bind(this)
 *                .chainAfter(this.test1.bind(this))
 *                .chainAfter(this.test2.bind(this))
 *         chain(1,2,3)
 *      }
 * }
 * 
 */
裝飾者模式
在不改變原有函數或對象功能的基礎上,給它們新加功能

用AOP裝飾函數

if (Function.prototype.before) {
    throw new Error("the before method already exist")
} else {
    Function.prototype.before = function (beforefn) {
        return () => {
            if (beforefn.apply(this, arguments)) {
                this.apply(this, arguments)
            }
        }
    }
}

if (Function.prototype.after) {
    throw new Error("the after method already exist")
} else {
    Function.prototype.after = function (afterfn) {
        return () => {
            this.apply(this, arguments)
            afterfn.apply(this, arguments)
        }
    }
}
狀態(tài)模式
允許一個對象在其內部狀態(tài)改變時改變它的行為,對象看起來似乎修改了它的類

要點:將狀態(tài)封裝成獨立的函數,并將請求委托給當前的狀態(tài)對象,當對象的內部狀態(tài)改變時,會帶來不同的行為變化

電燈的例子:

一個按鈕控制電燈的開關,按一下是開,再按一下是關

初始實現(xiàn):

class Light{
    constructor(){
        this.state="off",
        this.button=null
    }
    init(){
        //創(chuàng)建按鈕結點
        .....

        this.button.onClick=()=>{
            this.btnPressed()
        }
    }
    btnPressed(){
        if(this.state=="off"){
            this.state="on
        }else {
            this.state="off"
        }
    }
}

這段代碼的缺點就是不易擴展,當要加入一種閃動的狀態(tài)時,就要修改btnPressed中的代碼

使用狀態(tài)模式改寫

class Light{
    constructor(){
        this.state=FSM.off,
        this.button=null
    }
    init(){
        //創(chuàng)建按鈕結點
        .....

        this.button.onClick=()=>{
            this.state.btnPressed.call(this)
        }
    }
}

const FSM={
    on:{
        btnPressed(){
            //處理
            this.state=FMS.on
        }
    },
    off:{
        btnPressed(){
            //處理
            this.state=FMS.off
        }
    }
}

文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規(guī)行為,您可以聯(lián)系管理員刪除。

轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/89876.html

相關文章

  • 學習這些設計模式讓你寫出優(yōu)雅代碼

    摘要:寫代碼容易,寫出優(yōu)雅的代碼難,寫易于維護的容易擴展的結構清晰的代碼應該是每位開發(fā)者努力的目標,而學習設計模式,合理的的使用能讓我們離這個目標更進一步。 寫代碼容易,寫出優(yōu)雅的代碼難,寫易于維護的、容易擴展的、結構清晰的代碼應該是每位開發(fā)者努力的目標,而學習設計模式,合理的的使用能讓我們離這個目標更進一步。最近看了《Javascript設計模式與開發(fā)實踐》這本書,一言以蔽之,真不錯的一本...

    用戶84 評論0 收藏0
  • 這些JavaScript編程黑科技,裝逼指南,高逼格代碼,讓你驚嘆不已

    摘要:但是,構造函數注意是大寫的有點特別。構造函數接受的參數中,第一個是要傳入的參數名,第二個是函數內的代碼用字符串來表示。 Javascript是一門很吊的語言,我可能學了假的JavaScript,哈哈,大家還有什么推薦的,補充送那啥邀請碼。 本文秉承著:你看不懂是你SB,我寫的代碼就要牛逼。 1、單行寫一個評級組件 ★★★★★☆☆☆☆☆.slice(5 - rate, 10 - rate...

    曹金海 評論0 收藏0
  • 這些JavaScript編程黑科技,裝逼指南,高逼格代碼,讓你驚嘆不已

    摘要:但是,構造函數注意是大寫的有點特別。構造函數接受的參數中,第一個是要傳入的參數名,第二個是函數內的代碼用字符串來表示。 Javascript是一門很吊的語言,我可能學了假的JavaScript,哈哈,大家還有什么推薦的,補充送那啥邀請碼。 本文秉承著:你看不懂是你SB,我寫的代碼就要牛逼。 1、單行寫一個評級組件 ★★★★★☆☆☆☆☆.slice(5 - rate, 10 - rate...

    MorePainMoreGain 評論0 收藏0
  • 這些JavaScript編程黑科技,裝逼指南,高逼格代碼讓你驚嘆不已

    摘要:但是,構造函數注意是大寫的有點特別。構造函數接受的參數中,第一個是要傳入的參數名,第二個是函數內的代碼用字符串來表示。 Javascript是一門很吊的語言,我可能學了假的JavaScript,哈哈,大家還有什么推薦的,補充送那啥邀請碼。 本文秉承著:你看不懂是你SB,我寫的代碼就要牛逼。 1、單行寫一個評級組件 ★★★★★☆☆☆☆☆.slice(5 - rate, 10 - rate...

    isLishude 評論0 收藏0

發(fā)表評論

0條評論

songjz

|高級講師

TA的文章

閱讀更多
最新活動
閱讀需要支付1元查看
<