أنماط البرمجة الشيئية (OOP) في TypeScript: دليل لتصميم الفئات واستراتيجيات الوراثة

في عالم تطوير البرمجيات الحديث، برزت TypeScript كحجر الزاوية لبناء تطبيقات قوية وقابلة للتوسع والصيانة. يوفر نظامها القوي للأنواع، المبني على JavaScript، للمطورين الأدوات اللازمة لاكتشاف الأخطاء مبكرًا وكتابة تعليمات برمجية أكثر قابلية للتنبؤ. في جوهر قوة TypeScript يكمن دعمها الشامل لمبادئ البرمجة الشيئية (OOP). ومع ذلك، فإن مجرد معرفة كيفية إنشاء فئة لا يكفي. يتطلب إتقان TypeScript فهمًا عميقًا لتصميم الفئات، وتسلسلات الوراثة الهرمية، والمقايضات بين أنماط البناء المختلفة.

صُمم هذا الدليل لجمهور عالمي من المطورين، بدءًا من أولئك الذين يعززون مهاراتهم المتوسطة وصولاً إلى المهندسين المعماريين المتمرسين. سنتعمق في المفاهيم الأساسية للبرمجة الشيئية في TypeScript، ونستكشف استراتيجيات تصميم الفئات الفعالة، ونتناول النقاش القديم: الوراثة مقابل التركيب. وبنهاية المطاف، ستكون مجهزًا بالمعرفة اللازمة لاتخاذ قرارات تصميم مستنيرة تؤدي إلى قواعد بيانات برمجية أنظف وأكثر مرونة ومقاومة للمستقبل.

فهم أركان البرمجة الشيئية (OOP) في TypeScript

قبل أن نتعمق في الأنماط المعقدة، دعنا نرسخ أساسًا متينًا من خلال مراجعة الأركان الأربعة الأساسية للبرمجة الشيئية كما تنطبق على TypeScript.

1. التغليف (Encapsulation)

التغليف هو مبدأ تجميع بيانات الكائن (الخصائص) والوظائف التي تعمل على تلك البيانات في وحدة واحدة - فئة. ويتضمن أيضًا تقييد الوصول المباشر إلى الحالة الداخلية للكائن. تحقق TypeScript ذلك بشكل أساسي من خلال مُعدّلات الوصول: public وprivate وprotected.

مثال: حساب بنكي لا يمكن تعديل رصيده إلا من خلال وظيفتي الإيداع والسحب.

            class BankAccount {
  private balance: number = 0;

  constructor(initialBalance: number) {
    if (initialBalance >= 0) {
      this.balance = initialBalance;
    }
  }

  public deposit(amount: number): void {
    if (amount > 0) {
      this.balance += amount;
      console.log(`Deposited: ${amount}. New balance: ${this.balance}`);
    }
  }

  public getBalance(): number {
    // We expose the balance through a method, not directly
    return this.balance;
  }
}
            

              
                Copy
              
            
          

2. التجريد (Abstraction)

يعني التجريد إخفاء تفاصيل التنفيذ المعقدة وعرض الميزات الأساسية للكائن فقط. يسمح لنا بالتعامل مع المفاهيم عالية المستوى دون الحاجة إلى فهم الآلية المعقدة الكامنة وراءها. في TypeScript، غالبًا ما يتم تحقيق التجريد باستخدام الفئات abstract والواجهات interfaces.

مثال: عند استخدام جهاز تحكم عن بعد، ما عليك سوى الضغط على زر "التشغيل". لا تحتاج إلى معرفة الإشارات تحت الحمراء أو الدوائر الداخلية. يوفر جهاز التحكم عن بعد واجهة مجردة لوظائف التلفزيون.

3. الوراثة (Inheritance)

الوراثة هي آلية ترث بها فئة جديدة (فئة فرعية أو مشتقة) الخصائص والوظائف من فئة موجودة (فئة عليا أو أساسية). تعزز هذه الآلية إعادة استخدام التعليمات البرمجية وتنشئ علاقة "هو-نوع-من" واضحة بين الفئات. تستخدم TypeScript الكلمة المفتاحية extends للوراثة.

مثال: `Manager` (المدير) "هو-نوع-من" `Employee` (الموظف). يشتركون في خصائص مشتركة مثل `name` و`id`، لكن `Manager` قد يمتلك خصائص إضافية مثل `subordinates` (المرؤوسين).

            class Employee {
  constructor(public name: string, public id: number) {}

  getProfile(): string {
    return `Name: ${this.name}, ID: ${this.id}`;
  }
}

class Manager extends Employee {
  constructor(name: string, id: number, public subordinates: Employee[]) {
    super(name, id); // Call the parent constructor
  }

  // Managers can also have their own methods
  delegateTask(): void {
    console.log(`${this.name} is delegating tasks.`);
  }
}
            

              
                Copy
              
            
          

4. تعدد الأشكال (Polymorphism)

تعدد الأشكال، والذي يعني "أشكال متعددة"، يسمح بالتعامل مع كائنات من فئات مختلفة ككائنات من فئة عليا مشتركة. ويمكّن ذلك واجهة واحدة (مثل اسم وظيفة) من تمثيل أشكال أساسية مختلفة (تطبيقات). غالبًا ما يتحقق ذلك من خلال تجاوز الوظائف.

مثال: وظيفة `render()` تتصرف بشكل مختلف لكائن `Circle` مقارنة بكائن `Square`، على الرغم من أن كلاهما من `Shape`s.

            abstract class Shape {
  abstract draw(): void; // An abstract method must be implemented by subclasses
}

class Circle extends Shape {
  draw(): void {
    console.log("Drawing a circle.");
  }
}

class Square extends Shape {
  draw(): void {
    console.log("Drawing a square.");
  }
}

function renderShapes(shapes: Shape[]): void {
  shapes.forEach(shape => shape.draw()); // Polymorphism in action!
}

const myShapes: Shape[] = [new Circle(), new Square()];
renderShapes(myShapes);
// Output:
// Drawing a circle.
// Drawing a square.
            

              
                Copy
              
            
          

الجدل الكبير: الوراثة مقابل التركيب

هذا أحد أهم قرارات التصميم في البرمجة الشيئية (OOP). الحكمة الشائعة في هندسة البرمجيات الحديثة هي "تفضيل التركيب على الوراثة." دعنا نفهم السبب من خلال استكشاف كلا المفهومين بعمق.

ما هي الوراثة؟ علاقة "هو-نوع-من"

تنشئ الوراثة اقترانًا وثيقًا بين الفئة الأساسية والفئة المشتقة. عندما تستخدم extends، فإنك تشير إلى أن الفئة الجديدة هي نسخة متخصصة من الفئة الأساسية. إنها أداة قوية لإعادة استخدام التعليمات البرمجية عندما توجد علاقة هرمية واضحة.

• الإيجابيات:
  • إعادة استخدام التعليمات البرمجية: يتم تعريف المنطق المشترك مرة واحدة في الفئة الأساسية.
  • تعدد الأشكال: يسمح بسلوك أنيق ومتعدد الأشكال، كما رأينا في مثالنا عن `Shape`.
  • تسلسل هرمي واضح: إنه يحاكي نظام تصنيف واقعيًا من الأعلى إلى الأسفل.
• السلبيات:
  • الاقتران الوثيق: يمكن أن تؤدي التغييرات في الفئة الأساسية إلى تعطيل الفئات المشتقة عن غير قصد. يُعرف هذا بـ "مشكلة الفئة الأساسية الهشة".
  • جحيم التسلسل الهرمي: يمكن أن يؤدي الإفراط في الاستخدام إلى سلاسل وراثة عميقة ومعقدة وصارمة يصعب فهمها وصيانتها.
  • غير مرنة: يمكن للفئة أن ترث من فئة واحدة فقط في TypeScript (الوراثة الفردية)، وهو ما قد يكون مقيدًا. لا يمكنك وراثة الميزات من فئات متعددة غير ذات صلة.

متى تكون الوراثة خيارًا جيدًا؟

استخدم الوراثة عندما تكون العلاقة "هو-نوع-من" حقيقية ومستقرة ومن غير المرجح أن تتغير. على سبيل المثال، `CheckingAccount` و`SavingsAccount` كلاهما في الأساس نوعان من `BankAccount`. هذا التسلسل الهرمي منطقي ومن غير المرجح أن يُعاد نمذجته.

ما هو التركيب؟ علاقة "يمتلك"

يتضمن التركيب بناء كائنات معقدة من كائنات أصغر ومستقلة. بدلاً من أن تكون الفئة شيئًا آخر، فإنها تمتلك كائنات أخرى توفر الوظائف المطلوبة. يؤدي هذا إلى اقتران فضفاض، حيث تتفاعل الفئة فقط مع الواجهة العامة للكائنات المكونة.

• الإيجابيات:
  • المرونة: يمكن تغيير الوظائف في وقت التشغيل عن طريق تبديل الكائنات المركبة.
  • الاقتران الفضفاض: لا تحتاج الفئة المحتوية إلى معرفة التفاصيل الداخلية للمكونات التي تستخدمها. هذا يجعل التعليمات البرمجية أسهل في الاختبار والصيانة.
  • تجنب مشاكل التسلسل الهرمي: يمكنك دمج الوظائف من مصادر مختلفة دون إنشاء شجرة وراثة متشابكة.
  • مسؤوليات واضحة: يمكن لكل فئة مكونة الالتزام بمبدأ المسؤولية الواحدة.
• السلبيات:
  • رمز نموذجي أكثر: قد يتطلب أحيانًا المزيد من التعليمات البرمجية لربط المكونات المختلفة مقارنة بنموذج الوراثة البسيط.
  • أقل بديهية للتسلسلات الهرمية: لا يُنمذج التصنيفات الطبيعية بشكل مباشر مثلما تفعل الوراثة.

مثال عملي: السيارة

الـ `Car` (السيارة) هي مثال ممتاز للتركيب. فالـ `Car` ليست نوعًا من `Engine` (المحرك)، ولا هي نوع من `Wheel` (العجلة). بدلاً من ذلك، فإن الـ `Car` تمتلك `Engine` وتمتلك `Wheels`.

            // Component classes
class Engine {
  start() {
    console.log("Engine starting...");
  }
}

class GPS {
  navigate(destination: string) {
    console.log(`Navigating to ${destination}...`);
  }
}

// The composite class
class Car {
  private readonly engine: Engine;
  private readonly gps: GPS;

  constructor() {
    // The Car creates its own parts
    this.engine = new Engine();
    this.gps = new GPS();
  }

  driveTo(destination: string) {
    this.engine.start();
    this.gps.navigate(destination);
    console.log("Car is on its way.");
  }
}

const myCar = new Car();
myCar.driveTo("New York City");
            

              
                Copy
              
            
          

هذا التصميم مرن للغاية. إذا أردنا إنشاء `Car` بمحرك `ElectricEngine`، فلا نحتاج إلى سلسلة وراثة جديدة. يمكننا استخدام حقن التبعية (Dependency Injection) لتزويد `Car` بمكوناتها، مما يجعلها أكثر نمطية.

            interface IEngine {
  start(): void;
}

class PetrolEngine implements IEngine {
  start() { console.log("Petrol engine starting..."); }
}

class ElectricEngine implements IEngine {
  start() { console.log("Silent electric engine starting..."); }
}

class AdvancedCar {
  // The car depends on an abstraction (interface), not a concrete class
  constructor(private engine: IEngine) {}

  startJourney() {
    this.engine.start();
    console.log("Journey has begun.");
  }
}

const tesla = new AdvancedCar(new ElectricEngine());
tesla.startJourney();

const ford = new AdvancedCar(new PetrolEngine());
ford.startJourney();
            

              
                Copy
              
            
          

استراتيجيات وأنماط متقدمة في TypeScript

إلى جانب الاختيار الأساسي بين الوراثة والتركيب، توفر TypeScript أدوات قوية لإنشاء تصاميم فئات متطورة ومرنة.

1. الفئات المجردة (Abstract Classes): المخطط الأساسي للوراثة

عندما تكون لديك علاقة "هو-نوع-من" قوية ولكنك تريد التأكد من أنه لا يمكن إنشاء نسخ من الفئات الأساسية بمفردها، استخدم الفئات abstract. تعمل هذه الفئات كمخطط، حيث تحدد الوظائف والخصائص المشتركة، ويمكنها الإعلان عن وظائف abstract يجب على الفئات المشتقة تطبيقها.

حالة الاستخدام: نظام معالجة المدفوعات. أنت تعلم أن كل بوابة يجب أن تحتوي على وظيفتي `pay()` و`refund()`، لكن التنفيذ خاص بكل مزود (على سبيل المثال، Stripe، PayPal).

            abstract class PaymentGateway {
  constructor(public apiKey: string) {}

  // A concrete method shared by all subclasses
  protected connect(): void {
    console.log("Connecting to payment service...");
  }

  // Abstract methods that subclasses must implement
  abstract processPayment(amount: number): boolean;
  abstract issueRefund(transactionId: string): boolean;
}

class StripeGateway extends PaymentGateway {
  processPayment(amount: number): boolean {
    this.connect();
    console.log(`Processing ${amount} via Stripe.`);
    return true;
  }

  issueRefund(transactionId: string): boolean {
    console.log(`Refunding transaction ${transactionId} via Stripe.`);
    return true;
  }
}

// const gateway = new PaymentGateway("key"); // Error: Cannot create an instance of an abstract class.
const stripe = new StripeGateway("sk_test_123");
stripe.processPayment(100);
            

              
                Copy
              
            
          

2. الواجهات (Interfaces): تحديد عقود للسلوك

الواجهات في TypeScript هي طريقة لتحديد عقد لشكل الفئة. إنها تحدد الخصائص والوظائف التي يجب أن تحتوي عليها الفئة، لكنها لا توفر أي تنفيذ. يمكن للفئة أن implement عدة واجهات، مما يجعلها حجر الزاوية في التصميم التركيبي والفكاك.

الواجهة مقابل الفئة المجردة

• استخدم الفئة المجردة عندما ترغب في مشاركة التعليمات البرمجية المطبقة بين عدة فئات ذات صلة وثيقة.
• استخدم الواجهة عندما ترغب في تحديد عقد للسلوك يمكن تنفيذه بواسطة فئات مختلفة وغير ذات صلة.

حالة الاستخدام: في نظام ما، قد تحتاج العديد من الكائنات المختلفة إلى التحويل إلى تنسيق نصي (مثل للتسجيل أو التخزين). هذه الكائنات (`User`، `Product`، `Order`) غير مرتبطة ولكنها تشترك في قدرة مشتركة.

            interface ISerializable {
  serialize(): string;
}

class User implements ISerializable {
  constructor(public id: number, public name: string) {}

  serialize(): string {
    return JSON.stringify({ id: this.id, name: this.name });
  }
}

class Product implements ISerializable {
  constructor(public sku: string, public price: number) {}

  serialize(): string {
    return JSON.stringify({ sku: this.sku, price: this.price });
  }
}

function logItems(items: ISerializable[]): void {
  items.forEach(item => {
    console.log("Serialized item:", item.serialize());
  });
}

const user = new User(1, "Alice");
const product = new Product("TSHIRT-RED", 19.99);
logItems([user, product]);
            

              
                Copy
              
            
          

3. المكسينز (Mixins): نهج تركيبي لإعادة استخدام التعليمات البرمجية

نظرًا لأن TypeScript تسمح بالوراثة الفردية فقط، فماذا لو أردت إعادة استخدام التعليمات البرمجية من مصادر متعددة؟ هنا يأتي دور نمط المكسين (mixin). المكسينز هي وظائف تأخذ مُنشئًا وتعيد مُنشئًا جديدًا يوسعها بوظائف جديدة. إنه شكل من أشكال التركيب الذي يسمح لك "بمزج" القدرات في فئة.

حالة الاستخدام: تريد إضافة سلوكيات `Timestamp` (مع `createdAt`، `updatedAt`) و`SoftDeletable` (مع خاصية `deletedAt` و وظيفة `softDelete()`) إلى فئات نماذج متعددة.

            // A Type helper for mixins
type Constructor = new (...args: any[]) => T;

// Timestamp Mixin
function Timestamped(Base: TBase) {
  return class extends Base {
    createdAt: Date = new Date();
    updatedAt: Date = new Date();
  };
}

// SoftDeletable Mixin
function SoftDeletable(Base: TBase) {
  return class extends Base {
    deletedAt: Date | null = null;

    softDelete() {
      this.deletedAt = new Date();
      console.log("Item has been soft deleted.");
    }
  };
}

// Base class
class DocumentModel {
  constructor(public title: string) {}
}

// Create a new class by composing mixins
const UserAccountModel = SoftDeletable(Timestamped(DocumentModel));

const userAccount = new UserAccountModel("My User Account");
console.log(userAccount.title);
console.log(userAccount.createdAt);
userAccount.softDelete();
console.log(userAccount.deletedAt);
            

              
                Copy
              
            
          

الخاتمة: بناء تطبيقات TypeScript مقاومة للمستقبل

إتقان البرمجة الشيئية (OOP) في TypeScript هو رحلة من فهم بناء الجملة إلى تبني فلسفة التصميم. فالخيارات التي تتخذها فيما يتعلق بهيكل الفئات والوراثة والتركيب لها تأثير عميق على الصحة طويلة الأمد لتطبيقك.

فيما يلي أهم النقاط الرئيسية لممارسة تطويرك العالمية:

1. ابدأ بالأركان: تأكد من أن لديك فهمًا قويًا للتغليف (Encapsulation)، والتجريد (Abstraction)، والوراثة (Inheritance)، وتعدد الأشكال (Polymorphism). إنها مفردات البرمجة الشيئية.
2. فضل التركيب على الوراثة: سيقودك هذا المبدأ إلى تعليمات برمجية أكثر مرونة ونمطية وقابلية للاختبار. ابدأ بالتركيب ولا تلجأ إلى الوراثة إلا عندما توجد علاقة "هو-نوع-من" واضحة ومستقرة.
3. استخدم الأداة المناسبة للمهمة:
   • استخدم الوراثة للتخصص الحقيقي ومشاركة التعليمات البرمجية في تسلسل هرمي مستقر.
   • استخدم الفئات المجردة لتحديد أساس مشترك لعائلة من الفئات، ومشاركة بعض التطبيقات مع فرض عقد.
   • استخدم الواجهات لتحديد عقود للسلوك يمكن تطبيقها بواسطة أي فئة، مما يعزز فك الارتباط الشديد.
   • استخدم المكسينز عندما تحتاج إلى تركيب وظائف في فئة من مصادر متعددة، متغلبًا على قيود الوراثة الفردية.

من خلال التفكير النقدي في هذه الأنماط وفهم مقايضاتها، يمكنك تصميم تطبيقات TypeScript ليست قوية وفعالة اليوم فحسب، بل سهلة التكيف والتوسع والصيانة لسنوات قادمة - بغض النظر عن مكان وجودك أو فريقك في العالم.