ईश्वरीय संहिता (GOD का कोड)

"डिवाइन" कोड एक उच्च ध्वनि वाला शब्द है, जो एक पीले रंग की हेडिंग की तरह लग सकता है, लेकिन फिर भी यह ठीक ऐसा कोड है जिस पर चर्चा की जाएगी: इसमें कौन से हिस्से हैं और इसे कैसे लिखना है। यह यह सुनिश्चित करने के लिए मेरे प्रयासों के बारे में एक कहानी है कि कार्य नोट के साथ कोड समीक्षा के साथ वापस नहीं आते हैं: "सभी वह * nya --o।"

मेरे पास एक विशेष शिक्षा नहीं है, और मुझे गलतियों, घर्षणों और चोटों के माध्यम से व्यवहार में प्रोग्रामिंग सीखना था। लिखित कोड की गुणवत्ता में सुधार के लिए लगातार काम करते हुए, मैंने कुछ नियमों पर काम किया जिनके द्वारा इसका अनुपालन करना चाहिए। मैं उन्हें साझा करना चाहता हूं।

भगवान का कोड - संक्षिप्त नाम - कोड, ग्रैस, ऑब्जेक्ट कैलीथेनिक्स, डेमीटर के नियम और ठोस के सिद्धांतों के अनुसार लिखा गया है। किसी को वे सब जानते हैं, किसी ने केवल कुछ से मुलाकात की, लेकिन हम परिचित के प्रत्येक घटक पर विचार करेंगे। मैं नियमों के प्रत्येक समूह में विस्तार से गोता लगाने के अपने लक्ष्य के रूप में सेट नहीं करता हूं, क्योंकि वे इंटरनेट पर कई बार कवर किए गए हैं। इसके बजाय, मैं अपने अनुभव से एक निचोड़ पेश करता हूं।

GRASP

वर्गों और वस्तुओं को जिम्मेदारियां सौंपने के लिए नौ टेम्पलेट। याद रखने की सुविधा के लिए, मैं उन्हें दो उपसमूहों में विभाजित करता हूं:

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

और पढ़ें यहाँ

वस्तु कैलिसथेनिक्स

कोड निष्पादन नियमों का एक सेट जो कानूनों के कोड कोड के समान है। इनमें नौ भी हैं। मैं उन तीन के बारे में बात करूंगा जिन्हें मैं अपने दैनिक कार्य (थोड़ा संशोधित) में पालन करने की कोशिश करता हूं, बाकी मूल स्रोत में पढ़ा जा सकता है।

1. विधि की लंबाई 15 LOC से अधिक नहीं है, कक्षा में विधियों की संख्या 15 से अधिक नहीं है, एक नाम स्थान में कक्षाओं की संख्या 15 से अधिक नहीं है। निचला रेखा यह है कि कोड की लंबी शीट को पढ़ना और समझना बहुत मुश्किल है। इसके अलावा, लंबी कक्षाएं और तरीके एसआरपी के उल्लंघन का संकेत हैं (नीचे इस पर अधिक)।
2. प्रति विधि घोंसले के शिकार का अधिकतम एक स्तर।
   
   

   public function processItems(array items)
   {
        // 0
        foreach (items as item) {
             // 1
             for (i = 0; i < 5; i++) {
                  // 2
                  … process item 5 times …
             }
        }
   }

   
   item .
   
   

   public function processItems(array items)
   {
        // 0
        foreach (items as item) {
             // 1
             this.processItem(item);
        }
   }
    
   public function processItem(Item item)
   {
        // 0
        for (i = 0; i < 5; i++) {
             // 1
             … process item 5 times …
        }
   }

   
   -, — , , .
3. else , .
   
   

   public function processSomeDto(SomeDtoClass dto)
   {
        if (predicat) {
             throw new Exception(‘predicat is failed’);
        } else {
             return this.dtoProcessor.process(dto);
        }
   }

   
   :
   
   

   public function processSomeDto(SomeDtoClass dto)
   {
        if (predicat) {
             throw new Exception(‘predicat is failed’);
        }
    
        return this.dtoProcessor.process(dto);
   }

, .

GRASP’a. , .



: B, . . :

1. .
2. , .
3. .
4. , .

. , . this.objectB.objectC.getSomeStuff() , , .

. -, . :

public function methodA()
{
     spawnedObject = this.factory.spawn();
     spawnedObject.performSomeStuff();
}

:

public function methodA()
{
     this.factory.spawn().performSomeStuff();
}

, - .

public function methodA()
{
     this.processor.process(this.factory.spawn());
}

: DTO/Entity. .

public function methodA(SomeDtoClass dto)
{
     dto.getAddress().getCity();
}

, , . , , , , getCity DTO Address dto.

SOLID

SRP, OCP, LSP, ISP, DIP — , .

SRP — . — , . High Cohesion GRASP’a.

: , — - (MVC). - - , SRP.

public function indexAction(RequestInterface request): ResponseInterface
{
     requestDto = this.requestTransformer.transform(request);
     responseDto = this.requestProcessor.process(requestDto);
 
     return this.responseTransformer.transform(responseDto);
}

- , , — . , , , , .

OCP — -. , , .

- , if/switch. , . . — . , .

resolver, .

final lass Resolver implements ResolverInterface
{
     private mapping;
 
     public function Resolver(array mapping)
     {
          this.mapping = mapping;
     }
 
     public function resolve(Item item)
     {
          return this.mapping[item.getType()].perform(item);
     }
}

, . : , final, abstract, .

LSP — . , .

:

1. ( ).
2. ( , , , ).
3. ( ).
4. , ( , , , ).
   
   

   class ParentClass
   {
        public function someMethod(string param1)
        {
             // some logic
        }
   }
   
   class ChildClass extends ParentClass
   {
        public function someMethod(string param1, string param2)
        {
             if (param1 == '') {
                  throw new ExtraException();
             }
   
             // some logic
        }
   }

   
   

someMethod ChildClass (param2), param1, . , ParentClass ChildClass.

ISP — . , . , , , , — , .

interface DuckInterface
{
     public function swim(): void;

     public function fly(): void;
}

class MallardDuck implements DuckInterface
{
     public function swim(): void
     {
          // some logic
     }

     public function fly(): void
     {
          // some logic
     }
}

class RubberDuck implements DuckInterface
{
     public function swim(): void
     {
          // some logic
     }

     public function fly(): void
     {
          // can't fly :(
     }
}

RubberDuck DuckInterface. , , , DuckInterface FlyableInterface SwimableInterface, .

DIP — . , , ( , ). new .

class DIPViolation
{
     public function badMethod()
     {
          someService = new SomeService(445, 'second params');
          // operations with someService
     }
}

- , . . :

class DIP
{
     private $service;

     public function DIP(SomeServiceInterface $someService)
     {
          $this->someService = $someService;
     }

     public function goodMethod()
     {
          // operations with someService
     }
}

, , , , «» . , . , , , «», , :)