ویرگول
ورودثبت نام
Davood Habbabi
Davood Habbabiاگر وقت کنم چیزایی که یاد گرفتم رو می نویسم
Davood Habbabi
Davood Habbabi
خواندن ۵ دقیقه·۲ ماه پیش

اصول SOLID؛ چطور کدمون رو تمیزتر و قابل نگهداری‌تر بنویسیم؟ 🧑‍💻

اصول SOLID
اصول SOLID

اگر با برنامه‌نویسی شی‌گرا کار کرده باشی، احتمالاً یه جایی به کدی رسیدی که تغییر دادن یه قسمت کوچیکش باعث میشه سه جای دیگه خراب بشه! 😐

مثلاً یه کلاس داری که هم مسئول ارسال ایمیله، هم اطلاعات رو داخل دیتابیس ذخیره می‌کنه، هم لاگ می‌نویسه و هم گزارش تولید می‌کنه.

بعد یکی میاد میگه:

«فقط سیستم ارسال ایمیل رو تغییر بده.»

و تو با خودت میگی:

«فقط؟! 😂»

اینجاست که اصول SOLID به کمکمون میان.

SOLID مجموعه‌ای از ۵ اصل مهم در طراحی نرم‌افزاره که کمک می‌کنن کدمون:

  • قابل نگهداری‌تر باشه

  • راحت‌تر تغییر کنه

  • تست‌پذیرتر باشه

  • وابستگی‌های کمتری داشته باشه

  • و در پروژه‌های بزرگ کمتر تبدیل به کابوس بشه 😄

بیایم یکی‌یکی بررسیشون کنیم.


S — Single Responsibility Principle

اولین اصل میگه:

هر کلاس باید فقط یک مسئولیت داشته باشه و فقط به یک دلیل تغییر کنه.

فرض کن یه کلاس داریم که مسئول مدیریت کاربره:

class User { createUser(user) { // ذخیره کاربر در دیتابیس } sendEmail(user) { // ارسال ایمیل } generateReport(user) { // ساخت گزارش } }

در نگاه اول شاید مشکلی نبینیم.

ولی این کلاس الان چند مسئولیت مختلف داره:

User ├── مدیریت کاربر ├── ارسال ایمیل └── ساخت گزارش

حالا اگر سیستم ایمیل تغییر کنه، باید کلاس User رو تغییر بدیم.

اگر سیستم گزارش‌گیری تغییر کنه، باز باید همین کلاس رو تغییر بدیم.

اگر دیتابیس عوض بشه، باز...

یعنی یک کلاس برای چند دلیل مختلف ممکنه تغییر کنه.

راه بهتر چیه؟

مسئولیت‌ها رو جدا کنیم:

class UserService { createUser(user) { // ذخیره کاربر } } class EmailService { sendEmail(user) { // ارسال ایمیل } } class ReportService { generateReport(user) { // ساخت گزارش } }

حالا هر کلاس یه کار مشخص انجام میده.

یعنی:

UserService ↓ مدیریت کاربر EmailService ↓ ارسال ایمیل ReportService ↓ گزارش‌گیری

این همون Single Responsibility Principle هست.


O — Open/Closed Principle

اصل دوم میگه:

کلاس‌ها باید برای توسعه باز و برای تغییر بسته باشن.

این جمله اولش یکم عجیب به نظر میاد. 😐

یعنی چی؟

یعنی وقتی می‌خوایم قابلیت جدیدی اضافه کنیم، بهتره مجبور نباشیم کد قبلی رو مدام تغییر بدیم.

فرض کن سیستم پرداخت داریم:

class Payment { pay(type) { if (type === "card") { // پرداخت با کارت } if (type === "paypal") { // پرداخت با PayPal } } }

حالا فردا می‌خوایم پرداخت با:

Bitcoin Apple Pay Google Pay

هم اضافه کنیم.

پس دوباره میریم داخل همین کلاس و کلی if اضافه می‌کنیم:

if (type === "bitcoin") { // ... } if (type === "applepay") { // ... }

هر بار که قابلیت جدید اضافه می‌کنیم، کد قبلی رو تغییر می‌دیم.

یکی از راه‌های بهتر اینه که رفتارهای مختلف رو از هم جدا کنیم:

class CardPayment { pay() { console.log("Payment with card"); } } class PaypalPayment { pay() { console.log("Payment with PayPal"); } } class BitcoinPayment { pay() { console.log("Payment with Bitcoin"); } }

حالا اگر روش پرداخت جدیدی اضافه کنیم، لازم نیست کلاس‌های قبلی رو تغییر بدیم.

فقط یک کلاس جدید اضافه می‌کنیم:

class ApplePayPayment { pay() { console.log("Payment with Apple Pay"); } }

یعنی سیستم برای توسعه بازه ولی برای تغییر کدهای قبلی تا حد ممکن بسته است.


L — Liskov Substitution Principle

اصل سوم یکی از اون اصل‌هاییه که اسمش کمی ترسناکه! 😂

Liskov Substitution Principle

میگه:

هر جا از کلاس والد استفاده می‌کنیم، باید بتونیم از کلاس فرزند هم استفاده کنیم، بدون اینکه رفتار برنامه خراب بشه.

یه مثال معروف برای این موضوع، پرنده و پنگوئنه.

فرض کنیم:

class Bird { fly() { console.log("Flying..."); } }

حالا می‌گیم:

class Penguin extends Bird { }

مشکل چیه؟

پنگوئن پرنده‌ست، ولی نمی‌تونه پرواز کنه.

پس اگر این کار رو انجام بدیم:

const bird = new Penguin(); bird.fly();

به مشکل می‌خوریم.

چون قرارداد کلاس Bird گفته:

هر پرنده‌ای باید قابلیت fly() داشته باشه.

ولی Penguin نمی‌تونه این قرارداد رو رعایت کنه.

راه بهتر اینه که طراحی رو اصلاح کنیم:

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

حالا:

Bird ├── FlyingBird │ ├── Eagle │ └── Sparrow │ └── Penguin

دیگه پنگوئن مجبور نیست متدی داشته باشه که قادر به انجامش نیست.

پس اصل Liskov بهمون میگه:

وراثت نباید باعث بشه کلاس فرزند قرارداد کلاس والد رو نقض کنه.


I — Interface Segregation Principle

اصل چهارم میگه:

بهتره کلاس‌ها مجبور نشن Interfaceهایی رو پیاده‌سازی کنن که بهشون نیازی ندارن.

فرض کن یک Interface داریم:

interface Worker { work(); eat(); sleep(); }

حالا یک ربات داریم:

class Robot implements Worker { work() { // کار کردن } eat() { // 😐 ربات که غذا نمی‌خوره! } sleep() { // 😐 ربات هم نمی‌خوابه! } }

اینجا طراحی خوبی نداریم.

چون Robot مجبور شده متدهایی رو پیاده‌سازی کنه که اصلاً بهشون احتیاج نداره.

بهتره Interface بزرگ رو به Interfaceهای کوچک‌تر تقسیم کنیم:

interface Workable { work(); } interface Eatable { eat(); } interface Sleepable { sleep(); }

حالا انسان می‌تونه:

class Human implements Workable, Eatable, Sleepable { }

و ربات فقط:

class Robot implements Workable { }

این دقیقاً مفهوم Interface Segregation هست.

یعنی:

Interfaceهای بزرگ و شلوغ رو به قراردادهای کوچک‌تر و تخصصی‌تر تقسیم کنیم.


D — Dependency Inversion Principle

و می‌رسیم به آخرین اصل:

Dependency Inversion Principle

این اصل میگه:

کلاس‌های سطح بالا نباید مستقیماً به جزئیات سطح پایین وابسته باشن؛ هر دو باید به abstraction وابسته باشن.

فرض کن یک سرویس داریم:

class MySQLDatabase { save(data) { console.log("Saving to MySQL"); } } class UserService { constructor() { this.database = new MySQLDatabase(); } saveUser(user) { this.database.save(user); } }

در اینجا UserService مستقیماً به MySQLDatabase وابسته شده.

یعنی اگر فردا تصمیم بگیریم MySQL رو با MongoDB عوض کنیم، باید UserService رو تغییر بدیم.

بهتره وابستگی رو از بیرون بهش بدیم:

class UserService { constructor(database) { this.database = database; } saveUser(user) { this.database.save(user); } }

حالا می‌تونیم هر دیتابیسی که قرارداد لازم رو داشته باشه بهش بدیم:

const mysql = new MySQLDatabase(); const userService = new UserService(mysql);

یا:

const mongo = new MongoDatabase(); const userService = new UserService(mongo);

در نتیجه UserService دیگه اهمیتی نمی‌ده اطلاعات دقیقاً کجا ذخیره میشن.

فقط می‌دونه:

Database ↓ save()

این یعنی وابستگی ما به Abstraction هست، نه به یک پیاده‌سازی مشخص.


پس SOLID در یک نگاه یعنی چی؟

اگر بخوایم کل داستان رو خیلی خلاصه کنیم:

S → یک کلاس، یک مسئولیت O → برای توسعه باز، برای تغییر بسته L → فرزند باید قابل جایگزینی با والد باشد I → Interfaceهای کوچک و تخصصی D → وابستگی به abstraction، نه implementation

اما یه نکته مهم وجود داره.

SOLID قانون آهنین برنامه‌نویسی نیست.

قرار نیست هر جا یک کلاس دیدی، سریع پنج تا Interface و ده تا کلاس بسازی! 😂

هدف SOLID اینه که وقتی پروژه بزرگ‌تر شد و نیازمندی‌ها تغییر کردن، کدمون کمتر به هم وابسته باشه و تغییر دادن یک بخش، کل سیستم رو به هم نریزه.

در واقع میشه گفت:

SOLID بیشتر از اینکه درباره نوشتن کد کمتر باشه، درباره نوشتن کدی هست که تغییر دادنش دردسر کمتری داشته باشه.

اصول solidcleancodeoopprogramming
۱
۰
Davood Habbabi
Davood Habbabi
اگر وقت کنم چیزایی که یاد گرفتم رو می نویسم
شاید از این پست‌ها خوشتان بیاید