Ի՞նչ է Law of Demeter (LoD)-ը

LoD-ի հիմնական նպատակն է նվազեցնել օբյեկտների միջև կախվածությունները, որպեսզի կոդը լինի ավելի հեշտ փոփոխվող, թեստավորվող և կարդացվող։

Սկզբունքը սահմանում է, որ մեթոդը միայն պետք է շփվի հետևյալ տեսակների հետ՝

1. Ինքն իրեն (self)
2. Իր սեփական անդամ փոփոխականների հետ
3. Իր մեթոդների պարամետրերի հետ
4. Իր ստեղծած նոր օբյեկտների հետ

Այսինքն՝ պետք չէ ուղղակիորեն աշխատել օբյեկտի ենթաօբյեկտների հետ (chained calls), այլ դրա փոխարեն ապահովել միջնորդ մեթոդներ։

Վատ օրինակի

    class Engine {
      start() {
        console.log("Engine started");
      }
    }
    
    class Car {
      engine: Engine;
    
      constructor() {
        this.engine = new Engine();
      }
    
      getEngine(): Engine {
        return this.engine;
      }
    }
    
    class Driver {
      drive(car: Car) {
        car.getEngine().start(); //  Վատ պրակտիկա, քանի որ Driver-ը ուղղակիորեն օգտագործում է Engine-ը
      }
    }

Խնդիրն այստեղ այն է, որ Driver դասը կախվածություն ունի Car-ի Engine ենթաօբյեկտից, ինչը խախտում է LoD սկզբունքը։ Եթե վաղը Car-ը փոփոխվի ու այլ կառուցվածք ունենա, Driver-ը նույնպես պետք է փոփոխվի։

Լավ օրինակի

    class Engine {
      start() {
        console.log("Engine started");
      }
    }
    
    class Car {
      private engine: Engine;
    
      constructor() {
        this.engine = new Engine();
      }
    
      startEngine() {
        this.engine.start(); //  Միջնորդ մեթոդ
      }
    }
    
    class Driver {
      drive(car: Car) {
        car.startEngine(); // Այժմ `Driver`-ը միայն ճանաչում է `Car`-ը, ոչ թե `Engine`-ը
      }
    }

Այստեղ Driver-ը միայն աշխատում է Car-ի հետ, և այլևս ուղիղ կապ չունի Engine-ի հետ։ Եթե Car-ի ներսում ինչ-որ բան փոխվի, Driver-ը դրա մասին չպետք է իմանա։

LoD-ի առավելությունները

1. Նվազեցնում է կախվածությունները, ինչը հեշտացնում է կոդի փոփոխումը։
2. Բարելավում է մոդուլյարությունը՝ ապահովելով loose coupling։
3. Ամրապնդում է ինկապսուլյացիան՝ թույլ չտալով օբյեկտներին անմիջականորեն մուտք գործել այլ ենթաօբյեկտներ։
4. Կոդը դառնում է ավելի թեստավորվող, քանի որ mock-երը և dependency injection-ը դառնում են ավելի արդյունավետ։

Ե՞րբ է պետք խախտել LoD-ը

LoD-ի պահպանումը շատ կարևոր է, բայց այն երբեմն կարող է բարդացնել պարզ գործողությունները։ Եթե միջնորդ մեթոդներն ավելորդ են և պարզապես փոխադրում են ֆունկցիոնալությունը առանց ավելացնելու արժեք, հնարավոր է արժի խախտել սկզբունքը։