गेम ऑफ थ्रोन्स के उदाहरण पर ES6 + में स्ट्रक्चरल डिज़ाइन पैटर्न

• अनुकूलक
• डेकोरेटर
• मुखौटा
• अनुकूली (लाइटवेट (तत्व), फ्लाईवेट)
• प्रतिनिधि

अनुकूलक

• असंसदीय वर्ग
• ड्रैगन क्लास
• ड्रैगन क्लास बर्न मेथड टू किल कॉमन मेथड को पास करने के लिए एडॉप्टर क्लास

class Unsullied {
    constructor(name) {
        this.name = name
        this.kill = this.kill.bind(this)
    }

    kill() {
        console.log(`Unsullied ${this.name} kill`)
    }
}

class Dragon {
    constructor(name) {
        this.name = name
        this.burn = this.burn.bind(this)
    }

    burn() {
        console.log(`Dragon ${this.name} burn`)
    }
}

class DragonAdapter extends Dragon {
    kill() {
        this.burn()
    }
}

(() => {
    const Army = [
        new DragonAdapter('Rhaegal'),
        new Unsullied('Grey worm'),
        new DragonAdapter('Drogon')
    ]
    Army.forEach(soldier => soldier.kill())
})()

उपयोग के मामले

• जब नए घटकों या मॉड्यूल को एप्लिकेशन में मौजूदा के साथ काम करना चाहिए या जब रीफ़ैक्टरिंग के परिणामस्वरूप कोड का हिस्सा सुधार हुआ है, लेकिन पुराने भागों के साथ बातचीत करनी चाहिए।
• जब आपको द्वितीयक समस्याओं को हल करने के लिए एक पुस्तकालय मिला और आप इसे अपने आवेदन में एकीकृत करना चाहते हैं।

डेकोरेटर

• राजा वर्ग
• किंग जोफ्रे उदाहरण
• पीने का वर्ग
• कक्षा जहर पी लिया
• राजा के जीवन को बचाने के लिए कोई भी कार्य नहीं किया गया

function isNotPoisoned(t, n, descriptor) {
    const original = descriptor.value
    if(typeof original === 'function') {
        descriptor.value = function(...args) {
            const [drink] = args
            if(drink.constructor.name === 'poisonedDrink') throw new Error('Someone wants to kill the king')
            return original.apply(this, args)
        }
    }
    return descriptor
}

class PoisonedDrink {
    constructor(name) {
        this.name = name
    }
}

class Drink {
    constructor(name) {
        this.name = name
    }
}

class King {
    constructor(name) {
        this.name = name
    }

    //     
    //      
    @isNotPoisoned
    drink(drink) {
        console.log(`The king drank ${drink}`)
    }
}

(() => {
    const joffrey = new King('Joffrey Baratheon')
    const normalDrink = new Drink('water')
    const poisonedDrink = new Drink('poisoned water')
    joffrey.drink(normalDrink)
    joffrey.drink(poisonedDrink)
})()

डेकोरेटर उपयोग मामले

• जब हम विभिन्न संदर्भों के साथ बड़ी संख्या में वर्गों या विधियों में एक फ़ंक्शन जोड़ना चाहते हैं
• जब हम पहले से बनाई गई कक्षा में सुधार करना चाहते हैं, लेकिन पूर्ण रीफ़ैक्टरिंग के लिए समय नहीं है

मुखौटा

• सेना के नमूने
• सेनाफैड वर्ग

class Horse {
    constructor(name) {
        this.name = name
    }
    attack() {
        console.log(`Infantry ${this.name} attack`)
    }
}

class Soldier {
    constructor(name) {
        this.name = name
    }
    attack() {
        console.log(`Soldier ${this.name} attack`)
    }
}

class Giant {
    constructor(name) {
        this.name = name
    }
    attack() {
        console.log(`Giant ${this.name} attack`)
    }
}

class ArmyFacade {
    constructor() {
        //  ,           
        this.army = [];
        (new Array(10)).fill().forEach((_, i) => this.army.push(new Horse(i + 1)));
        (new Array(10)).fill().forEach((_, i) => this.army.push(new Soldier(i + 1)));
        (new Array(1)).fill().forEach((_, i) => this.army.push(new Giant(i + 1)));
        this.getByType = this.getByType.bind(this)
    }
    getByType(type, occurency) {
        return this.army.filter(el => {
            return el.constructor.name === type && occurency-- > 0
        })
    }
    attack(armyInfo = {}) {
        const keys = Object.keys(armyInfo)
        let subArmy = []
        keys.forEach(soldier => {
            switch(soldier) {
                case 'horse': {
                    subArmy = [...subArmy, ...this.getByType('Horse', armyInfo.horse)]
                    break;
                }
                    case 'soldier': {
                    subArmy = [...subArmy, ...this.getByType('Soldier', armyInfo.soldier)]
                    break;
                }
                    case 'giant': {
                    subArmy = [...subArmy, ...this.getByType('Giant', armyInfo.giant)]
                    break;
                }
            }
        })
        subArmy.forEach(soldier => soldier.attack())
    }
}

(() => {
    const army = new ArmyFacade()
    army.attack({
        horse: 3,
        soldier: 5,
        giant: 1
    })
})()

बक्सों का इस्तेमाल करें

• जब हम कोड की कई पंक्तियों को बदलना चाहते हैं, तो संभवतः दोहराते हुए, एक साधारण फ़ंक्शन में।

अवसरवादी

• ज़िंदा
• मृत
• पुनर्जीवित

• श्वेतवर्णी वर्ग
• वर्ग व्हाइटवल्करफ्लाइट
• सफेद वॉकर के पुनरुत्थान के लिए ग्राहक

class WhiteWalker {
    constructor({
        sprite,
        someOtherBigInformation
    }) {
        this.sprite = sprite
        this.someOtherBigInformation = someOtherBigInformation
        this.state = 'alive'
        this.resurrect = this.resurrect.bind(this)
        this.kill = this.kill.bind(this)
        this.getState = this.getState.bind(this)
    }
    kill() {
        this.state = 'dead'
    }
    resurrect() {
        this.state = 'resurrected'
    }
    getState() {
        return this.state
    }
}

const whiteWalker = new WhiteWalker({
    sprite: Date.now()
})

class WhiteWalkerFlyweight {
    constructor(position, name) {
        this.position = position
        this.name = name
        this.whiteWalker = whiteWalker
    }
    getInfo() {
        console.log(`The White Walker ${this.name} whit sprite ${this.whiteWalker.sprite} is ${this.whiteWalker.state}`)
    }
    getFatherInstance() {
        return this.whiteWalker
    }
}

(() => {
    const myArmy = []
    for(let i = 0; i < 10; i++) {
        myArmy.push(new WhiteWalkerFlyweight({
            x: Math.floor(Math.random() * 200),
            y: Math.floor(Math.random() * 200),
        }, i + 1))
    }
    myArmy.forEach(soldier => soldier.getInfo())
    console.log('KILL ALL')
    const [onOffWhiteWalker] = myArmy
    onOffWhiteWalker.getFatherInstance().kill()
    myArmy.forEach(soldier => soldier.getInfo())
    console.log('RESURRECT ALL')
    onOffWhiteWalker.getFatherInstance().resurrect()
    myArmy.forEach(soldier => soldier.getInfo())
})()

बक्सों का इस्तेमाल करें

• जब हम बड़ी संख्या में ऑब्जेक्ट बनाने से बचना चाहते हैं
• जब हम ऐसी वस्तुओं का निर्माण करना चाहते हैं जो स्मृति की एक बड़ी मात्रा का उपभोग करती हैं
• जब हमें ऐसी वस्तुओं की आवश्यकता होती है जिनके निर्माण के लिए जटिल गणना की आवश्यकता होती है
• जब हमारे पास संसाधनों की सीमित आपूर्ति होती है: कंप्यूटिंग पावर, मेमोरी, स्पेस इत्यादि।

प्रॉक्सी

• वर्ग सैनिक
• प्रक्रिया नियंत्रण के लिए सेनाप्रॉक्सी वर्ग
• अनुमति के लिए सेरेसी वर्ग के उदाहरण

class Soldier {
    constructor(name) {
        this.name = name
    }
    attack() {
        console.log(`Soldier ${this.name} attack`)
    }
}

class Queen {
    constructor(name) {
        this.name = name
    }
    getConsent(casualNumber) {
        return casualNumber %2 === 0
    }
}

class ArmyProxy {
    constructor() {
        this.army = []
        this.available = 0
        this.queen = new Queen('Cercei')
        this.getQueenConsent = this.getQueenConsent.bind(this)
    }

    getQueenConsent() {
        return this.queen.getConsent(Math.floor(Math.random() * 200))
    }

    enrollSoldier() {
        if(!this.available) {
            const consent = this.getQueenConsent()
            if(!consent) {
                console.error(`The queen ${this.queen.name} deny the consent`)
                return
            }
            this.available = 100
        }
        this.army.push(new Soldier(this.army.length))
        this.available--
    }
}

(() => {
    const myArmy = new ArmyProxy()
    for(let i = 0; i < 1000; i++) {
        myArmy.enrollSoldier()
    }
    console.log(`I have ${myArmy.army.length} soldiers`)
})()

बक्सों का इस्तेमाल करें

• जब हम जिस वस्तु का उपयोग करना चाहते हैं वह बहुत दूर है (गहराई से नेस्टेड) ​​और प्रॉक्सी को लॉजिक में सेव करें ताकि क्लाइंट को प्रभावित न करें
• जब हम एक वास्तविक परिणाम की प्रत्याशा में एक अनुमानित परिणाम देना चाहते हैं, जिसकी गणना में बहुत समय लगता है
• जब हम किसी वस्तु की पहुंच या निर्माण को उसके तर्क के साथ हस्तक्षेप किए बिना नियंत्रित करना चाहते हैं