SOLID սկզբունքները JavaScript-ի OOP-ում

SOLID սկզբունքները հինգ հիմնարար կանոններ են, որոնք օգնում են կառուցել կարդացվող, ընդարձակելի և թեստավորվող ծրագրեր՝ օգտագործելով օբյեկտ-օրիենտացված մոտեցում։ Չնայած JavaScript-ը դինամիկ լեզու է, այդ սկզբունքները կիրառելի են նաև այստեղ։

Անվանումը բաղկացած է հինգ սկզբունքներից՝

• S - Single Responsibility Principle (Մեկ պատասխանատվության սկզբունք)
• O - Open/Closed Principle (Բաց/Փակ սկզբունք)
• L - Liskov Substitution Principle (Լիսկովի փոխարինելիության սկզբունք)
• I - Interface Segregation Principle (Ինտերֆեյսների տարանջատման սկզբունք)
• D - Dependency Inversion Principle (Անկախության շրջման սկզբունք)

---

1. Single Responsibility Principle (SRP)

Յուրաքանչյուր class կամ ֆունկցիա պետք է ունենա միայն մեկ պատասխանատվություն։

class User { constructor(name) { this.name = name; } }
class UserPrinter { print(user) { console.log(User: ${user.name}); } }

Օգտակարություն՝

• Ապահովում է separation of concerns
• Կոդի թեստավորումը դառնում է ավելի հեշտ

---

2. Open/Closed Principle (OCP)

Կոդը պետք է լինի բաց ընդլայնման, բայց փակ փոփոխման համար։

class Shape { area() { throw new Error('area() not implemented'); } }
class Circle extends Shape { constructor(radius) { super(); this.radius = radius; }

area() { return Math.PI * this.radius ** 2; } }

function printArea(shape) { console.log(shape.area()); }

Օգտակարություն՝

• Նոր պահվածք ավելացնելու համար անհրաժեշտ չէ փոփոխել գոյություն ունեցող կոդը

---

3. Liskov Substitution Principle (LSP)

Երբ class A ժառանգվում է class B-ից, ապա A-ի օբյեկտները պետք է կարողանան փոխարինել B-ին առանց սխալ արդյունքների։

class Bird { fly() { console.log('Flying'); } }
class Penguin extends Bird { fly() { throw new Error('Penguins cannot fly'); } }

Այստեղ Penguin-ը խախտում է LSP։ Լուծում՝ վերաձևակերպել հիերարխիան․

class Bird {}
class FlyingBird extends Bird { fly() { console.log('Flying'); } }

class Penguin extends Bird { swim() { console.log('Swimming'); } }

Օգտակարություն՝

• Պահում է ժառանգականության տրամաբանությունը

---

4. Interface Segregation Principle (ISP)

Օբյեկտները չպետք է պարտադրված լինեն իրագործել այն ֆունկցիաները, որոնք չեն օգտագործում։

JavaScript-ում սա կարելի է հասկանալ որպես՝ չպետք է ստեղծել մեծ class-եր բազմաթիվ ոչ փոխկապակցված մեթոդներով։

class MultiFunctionPrinter { print() {} scan() {} fax() {} }
class SimplePrinter { print() {} // scan(), fax() անհրաժեշտ չեն }

Ավելի լավ է՝ փոքր ինտերֆեյսների մոտեցում․

class Printer { print() {} }
class Scanner { scan() {} }

Օգտակարություն՝

• Ապահովում է մոդուլայնություն
• Կոմպոզիցիան դառնում է ավելի հեշտ

---

5. Dependency Inversion Principle (DIP)

Մոդուլները չպետք է կախված լինեն կոնկրետ իրագործումներից, այլ՝ աբստրակցիաներից։

class MySQLDatabase { save(data) { console.log(`Saving ${data} to MySQL`); } }
class UserService { constructor(database) { this.database = database; }

saveUser(user) { this.database.save(user); } }

const db = new MySQLDatabase(); const service = new UserService(db); service.saveUser('John');

Այստեղ UserService-ը աշխատում է MySQLDatabase-ի աբստրակցիայի վրա։ Եթե վաղը մենք որոշենք օգտագործել MongoDB, պետք է փոխենք միայն ինստանսի տիպը։

Օգտակարություն՝

• Ավելի հեշտ է փոխել ներքին համակարգերը
• Թեստավորումը դառնում է ավելի պարզ

---

Եզրակացություն

SOLID սկզբունքները JavaScript-ում օգնում են ստեղծել մաքուր, ընդարձակելի և անվտանգ կոդ։ Դրանք կիրառելով՝ մենք կարող ենք նախագծել կոդային բազա, որը դիմանում է փոփոխություններին՝ առանց կոտրվելու։

Հաջորդ մասում կանդրադառնանք Module Pattern-ին և Reveal Pattern-ին JavaScript-ում՝ OOP աշխարհում օգտագործվող մոդուլային կառույցներին։

---