Clean Code JavaScript-ում

Մաքուր կոդը (Clean Code) ոչ միայն կարդացվող և հասկանալի կոդ է, այլև այնպիսի կոդ, որը հեշտ է թեստավորել, ընդլայնել և աջակցել։ JavaScript-ում հաճախ դժվար է պահպանել մաքրությունը, հատկապես երբ արագ լուծումներ ենք փնտրում։ Այս հոդվածում մենք կծանոթանանք հիմնական սկզբունքներին, որոնք օգնում են գրել ավելի լավ կառուցված կոդ։

Դրանք են՝ DRY, KISS, YAGNI և SOLID սկզբունքները։

---

DRY (Don't Repeat Yourself)

  
// Վատ օրինակը
function calculateRectangleArea(width, height) {
  return width * height;
}

function calculateRectanglePerimeter(width, height) {
  return 2 * width + 2 * height;
}

function describeRectangle(width, height) {
  const area = width * height;
  const perimeter = 2 * width + 2 * height;
  return `Area: ${area}, Perimeter: ${perimeter}`;
}
  

Լավ տարբերակ՝ վերօգտագործում ենք լոգիկան.

  
function calculateRectangleArea(width, height) {
  return width * height;
}

function calculateRectanglePerimeter(width, height) {
  return 2 * (width + height);
}

function describeRectangle(width, height) {
  const area = calculateRectangleArea(width, height);
  const perimeter = calculateRectanglePerimeter(width, height);
  return `Area: ${area}, Perimeter: ${perimeter}`;
}
  

Առավելությունները՝

• Փոփոխությունը կատարվում է միայն մեկ տեղում
• Կոդը դառնում է ավելի հասկանալի

---

KISS (Keep It Simple, Stupid)

  
// Վատ օրինակը
function isEven(num) {
  return num % 2 === 0 ? true : false;
}
  

Լավ տարբերակ՝

  
function isEven(num) {
  return num % 2 === 0;
}
  

Առավելությունները՝

• Ավելի կարճ և հեշտ ընթեռնելի կոդ
• Թաքնված բարդություն չկա

---

YAGNI (You Aren’t Gonna Need It)

  
// Վատ օրինակը՝ ավելորդ ֆունկցիոնալություն
function sendMessage(user, message, isUrgent = false, sendCopyToAdmin = false) {
  // այս պահի դրությամբ admin-ին պատճեն ուղարկելու անհրաժեշտություն չկա
  if (sendCopyToAdmin) {
    // ուղարկել admin-ին
  }
  // ուղարկել օգտատիրոջը
}
  

Լավ տարբերակ՝

  
function sendMessage(user, message) {
  // ուղարկել օգտատիրոջը
}
  

Առավելությունները՝

• Չենք ավելացնում չօգտագործվող ֆունկցիոնալություն
• Ապագա փոփոխությունները կկատարվեն ըստ անհրաժեշտության

---

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

SOLID-ը բաղկացած է 5 սկզբունքից, որոնք օգնում են գրել ավելի ճկուն և ընդլայնելի կոդ։

1. Single Responsibility Principle (SRP)

  
// Վատ օրինակը
class UserManager {
  createUser(userData) { /* ստեղծել օգտատեր */ }
  sendWelcomeEmail(user) { /* ուղարկել նամակ */ }
}
  

  
// Լավ տարբերակ
class UserManager {
  createUser(userData) { /* ստեղծել օգտատեր */ }
}

class EmailService {
  sendWelcomeEmail(user) { /* ուղարկել նամակ */ }
}
  

Առավելությունները՝

• Յուրաքանչյուր կլասս ունի միայն մեկ պատասխանատվություն

---

2. Open/Closed Principle (OCP)

  
// Վատ օրինակը
function discount(price, type) {
  if (type === 'regular') return price;
  if (type === 'vip') return price * 0.9;
}
  

  
// Լավ տարբերակ՝ ընդլայնելի դասեր
class RegularCustomer {
  getDiscount(price) {
    return price;
  }
}

class VipCustomer {
  getDiscount(price) {
    return price * 0.9;
  }
}
  

Առավելությունները՝

• Կոդը բաց է ընդլայնման, փակ՝ փոփոխման համար

---

3. Liskov Substitution Principle (LSP)

  
// Վատ օրինակը
class Bird {
  fly() {}
}

class Penguin extends Bird {
  fly() {
    throw new Error("Penguins can't fly!");
  }
}
  

  
// Լավ տարբերակ՝ տարբեր հիմքեր
class Bird {}
class FlyingBird extends Bird {
  fly() {}
}

class Penguin extends Bird {
  swim() {}
}
  

Առավելությունները՝

• Ենթադասերը կարող են փոխարինել մայր դասերին առանց սխալների

---

4. Interface Segregation Principle (ISP)

  
// Վատ օրինակը՝ մեծ ինտերֆեյս
class Machine {
  print() {}
  scan() {}
  fax() {}
}
  

  
// Լավ տարբերակ՝ մասնագիտացված ինտերֆեյսներ
class Printer {
  print() {}
}

class Scanner {
  scan() {}
}
  

Առավելությունները՝

• Յուրաքանչյուր դաս կստանա միայն այն մեթոդները, որոնք իրեն անհրաժեշտ են

---

5. Dependency Inversion Principle (DIP)

  
// Վատ օրինակը՝ կոշտ կապ կախվածության վրա
class MySQLDatabase {
  save(data) {}
}

class UserService {
  constructor() {
    this.db = new MySQLDatabase();
  }
}
  

  
// Լավ տարբերակ՝ կախվածությունը փոխանցվում է
class UserService {
  constructor(database) {
    this.db = database;
  }
}
  

Առավելությունները՝

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

---