शुरुआती लोगों के लिए वास्तुकला या आपको तलवार वाले आदमी में झंडा डालने की आवश्यकता क्यों नहीं है

एनोटेशन:

1. एक "ध्वज" जोड़कर कक्षा में नई कार्यक्षमता के कार्यान्वयन का एक उदाहरण।
2. प्रभाव।
3. वैकल्पिक दृष्टिकोण और परिणामों की तुलना।
4. स्थिति से कैसे बचें: "आर्किटेक्चरल ओवरकिल"?
5. वह पल जब सब कुछ बदलने का समय आता है।

class Hero {
    func strike() {
        //   1
    }
    //   
}

class Hero {
    enum WeaponTypes {
        case sword:
        case club:
    }
	
    var weaponType: WeaponTypes?

    func strike() {
        guard let weaponType = weaponType else {
            assertionFailure()
            return	
        }
        //  : switch  Swift  if- -    !
        switch (weaponType) {
            case .sword: //     
            case .club:  //     
        }
    }
    //  
}

1. जैसे कि अच्छा: हम दोनों उद्धार करते हैं। हम डिलीवर करते हैं - शब्द डिलीवर वैल्यू से या फनी (आंसू) कोड से।
2. और बुरा एक: वसीली के बिना, कापेट प्रोजेक्ट।

var weight: Stone {
    return meatbagWeight + pantsWeight + helmetWeight + swordWeight
}

var weight: Stone {
    //   guard let weaponType
    let weightWithoutWeapon = meatbagWeight + pantsWeight + helmetWeight
    switch (weaponType) {
        case .sword: return weightWithoutWeapon + swordWeight
        case .club:  return weightWithoutWeapon + clubWeight
    }
}

var spells: [Spells] {
    //   guard let weaponType 
    // ,   let spellsWithoutWeapon: [Spells]
    switch (weaponType) {
        case .sword:
            //  let swordSpells: [Spells]
            return spellsWithoutWeapon + swordSpells
	case .club:
            //  let clubSpells: [Spells]
            return spellsWithoutWeapon + clubSpells
    }
}

func strike() {
    //guard let weaponType
    switch (weaponType) {
        case .sword: //        weaponGrade
        case .club:  //        weaponGrade
    }
}

var weight: Stone {
    // guard let weaponType
    let weightWithoutWeapon = meatbagWeight + pantsWeight + helmetWeight
    switch (weaponType) {
        case .sword: return weightWithoutWeapon + swordWeight / grade
	case .club:  return weightWithoutWeapon + pow(clubWeight, 1 / grade)
    }
}

var spells: [Spells] {
    //     , ! 
    // ,     .    ,    ,   .   !
}

सभी बुराईयो की जड़ समयपूर्व इष्टतमीकरण है!

1. पहला तरीका "भोला" है। हमने बस उसे देखा। एक चेकबॉक्स जोड़ना। जिम्मेदारी जोड़ना। सूजन वर्ग।
2. दूसरा तरीका वंशानुक्रम है। हर कोई कोड के पुन: उपयोग के लिए एक शक्तिशाली तंत्र जानता है। एक, उदाहरण के लिए:
   
   • नए हीरो के साथ बो और हीरो के साथ डुबिना से हीरो (जो एक तलवार पकड़े हुए है, लेकिन यह अब हीरो वर्ग के नाम से परिलक्षित नहीं होता है) को विरासत में मिला है। और फिर वारिसों में, परिवर्तित तरीकों को ओवरराइड करें। यह रास्ता बहुत बुरा है (बस मुझे भरोसा है)।
   • बेस क्लास (या प्रोटोकॉल) को हीरो बनाएं, और एक विशिष्ट प्रकार के हथियार से जुड़े सभी फीचर्स को वारिस के रूप में हटा दें
     : हीरो विथ ए
     तलवार: हीरो, हीरो विथ ए धनुष: हीरो, हीरो विथ
     दुबीना: हीरो।
     यह बेहतर है, लेकिन इन वर्गों के नाम खुद हमें किसी भी तरह से नाराज, भयंकर और एक ही समय में दुखी और हैरान महसूस करते हैं। अगर वे उस तरह से किसी को नहीं देखते हैं, तो मैं एक और लेख लिखने की कोशिश करूंगा, जहां उबाऊ मर्दाना हीरो के अलावा वे होंगे ...
3. तीसरा तरीका निर्भरता इंजेक्शन के माध्यम से जिम्मेदारी का पृथक्करण है। यह एक प्रोटोकॉल या एक बंद (जैसे कि एक हस्ताक्षर द्वारा बंद) द्वारा निर्भरता हो सकती है, जो भी हो। मुख्य बात यह है कि नई जिम्मेदारियों का कार्यान्वयन मुख्य वर्ग को छोड़ देना चाहिए।

class Hero {
    let weapon: Weapon //   , ..    

    init (_ weapon: Weapon) { //     
        self.weapon = weapon
    }
	
    func strike() {
        weapon.strike()
    }

    var weight: Stone {
        return meatbagWeight + pantsWeight + helmetWeight + weapon.weight
    }

    var spells: [Spells] {
        //   
        return spellsWithoutWeapon + weapon.spells
    }
}

protocol Weapon {
    func strike()
    var weight: Stone {get}
    var spells: [Spells] {get}
}

class Sword: Weapon {
    func strike() {
        // ,     Hero  switch   .sword
    }

    var weight: Stone {
        // ,     Hero  switch   .sword
    }

    var spells: [Spells] {
        // ,     Hero  switch   .sword
    }
}

let lastHero = Hero()

class HeroFactory {
    static func makeSwordsman() -> Hero { // ,  static -  
        let weapon = Sword(/*  */)
        return Hero(weapon)
    }

    static func makeClubman() -> Hero {
        let weapon = Club(/*  */)
        return Hero(weapon)
    }
}

ठीक है, यह निकला, मानदंड। यह पढ़ना और विस्तार करना सुविधाजनक है, लेकिन क्या ये सभी कारखाने / प्रोटोकॉल / निर्भरताएं ओवरहेड्स का एक गुच्छा हैं? एक कोड जो सुविधाओं के संदर्भ में कुछ भी नहीं देता है, लेकिन केवल कोड को व्यवस्थित करने के लिए मौजूद है। "कोड के आयोजन के लिए कोड", एमजीएम। क्या इस बाग को हमेशा और हर जगह फैंस करना जरूरी है?

हां, यह उन विशेषताओं के लिए एक ओवरहेड है जो व्यवसाय बहुत पसंद करता है।

तलवार-आदमी का दर्शन या "आपको कब शासन करना है?"

1. तलवार के लिए आदमी + की लत (तलवार की जरूरत);
2. एक क्लब के लिए आदमी + की लत (एक क्लब की आवश्यकता)।

1. झंडे को जोड़ना और ध्वज को पहले "अगर" (या "स्विच", या अन्य शाखा तंत्र)। स्थिति खतरे में है, लेकिन मुस्कराते हुए: नायक को रेडियोधर्मी कचरे के साथ डाला जाता है, लेकिन वह इसे खत्म कर देता है।
2. «if» , . . — . , - - .

1. झंडा देखें?
2. मर्द बनो, धिक्कार है! इसे मिटाएं!
3. नशे का इंजेक्शन
4. ...
5. लाभ! ११