الدليل الشامل للأنواع العامة المتقدمة في TypeScript: الفئات والقيود وهندسة المعمارية البرمجية (الجزء الثاني)

المقدمة والنظرة الشاملة

مرحباً بكم من جديد في رحاب عالم TypeScript المثير! بعد أن استكشفنا في الجزء الأول من موضوع الأنواع العامة (Generics) كيف يمكنها أن تُثري دوالنا وواجهاتنا بمرونة لا مثيل لها مع الحفاظ على صرامة فحص الأنواع، ننتقل الآن إلى مستوى أعمق وأكثر قوة. في هذا الجزء الثاني، سنُبحر في كيفية دمج الأنواع العامة مع الفئات (Classes) لإنشاء هياكل بيانات وتصاميم برمجية متكيفة، وسنتعرف على مفهوم قيود الأنواع العامة (Generic Constraints) الذي يسمح لنا بفرض شروط معينة على الأنواع التي يمكن استخدامها، مما يفتح آفاقاً واسعة لتطوير حلول برمجية أكثر أماناً وفعالية.

تُعد الأنواع العامة حجر الزاوية في بناء برمجيات قابلة لإعادة الاستخدام ومرنة للغاية، خاصةً عند التعامل مع هياكل البيانات التي تحتاج إلى العمل مع أنواع مختلفة من البيانات دون الحاجة إلى تكرار الكود. تخيل أنك تقوم بإنشاء قائمة مرتبطة (Linked List) أو مكدس (Stack) أو طابور (Queue)؛ بدون الأنواع العامة، ستضطر إما إلى استخدام النوع any، مما يُفقدنا ميزة التحقق من الأنواع في وقت التطوير، أو إنشاء نسخة منفصلة من كل هيكل لكل نوع بيانات تريد تخزينه، وهو ما يُعد إهداراً كبيراً للوقت والجهد ومصدراً محتملاً للأخطاء. هنا يأتي دور الأنواع العامة لتقديم الحل الأمثل الذي يجمع بين المرونة الكاملة والأمان النوعي الصارم في وقت الترجمة (Compile-time Type Safety).

الأنواع العامة مع الفئات (Generic Classes)

في TypeScript، يمكننا تعريف الفئات لتكون عامة، مما يعني أنها يمكن أن تعمل مع أي نوع من البيانات نحدده عند إنشاء كائن من هذه الفئة. هذه الميزة بالغة الأهمية لتطوير مكتبات أو مكونات قابلة لإعادة الاستخدام. عند تعريف فئة عامة، نقوم بتحديد معامل نوع (Type Parameter) واحد أو أكثر بين أقواس زاوية (<T>) بعد اسم الفئة. هذا المعامل يمثل نوع البيانات الذي ستتعامل معه الفئة.

على سبيل المثال، يمكننا إنشاء فئة بسيطة لتخزين قيمة واحدة من أي نوع، مثل صندوق (Box) يمكن أن يحتوي على أي شيء. هذا الصندوق سيضمن لنا أن القيمة المخزنة فيه هي من النوع الذي حددناه عند إنشاء الصندوق، وسيمكننا استرجاعها بنفس النوع دون الحاجة لعمليات تحويل قسرية (Type Assertion) غير آمنة:

class Box<T> {
    private content: T;

    constructor(initialContent: T) {
        this.content = initialContent;
    }

    public getContent(): T {
        return this.content;
    }

    public setContent(newContent: T): void {
        this.content = newContent;
    }
}

// إنشاء صندوق مخصص للنصوص
const stringBox = new Box<string>("مرحباً بك في كود التطور");
console.log(stringBox.getContent().toUpperCase()); // دعم كامل لدوال النصوص

// إنشاء صندوق مخصص للبيانات المعقدة
interface Product {
    id: number;
    title: string;
    price: number;
}

const productBox = new Box<Product>({
    id: 101,
    title: "شاشة حاسوب فائقة الدقة",
    price: 450
});

console.log(productBox.getContent().price); // وصول آمن للحقول البرمجية

الجزء الثاني: الفئات والقيود في الأنواع العامة (Generics)

المفاهيم الأساسية والأهمية الهندسية

في درسنا السابق، تعرفنا على الأنواع العامة (Generics) وأهميتها في TypeScript. الآن، سنتعمق أكثر في مفهوم الأنواع العامة ونستكشف العناصر الأساسية والقيود المتعلقة بها. يعتبر فهم هذه المفاهيم مفتاحاً لتطوير تطبيقات قوية وموثوقة.

عندما نستخدم الأنواع العامة بصورتها المطلقة <T>، يعامل المترجم النوع T على أنه يمكن أن يكون أي شيء على الإطلاق (Unknown Type Shape). هذا يعني أنك داخل الفئة أو الدالة لن تتمكن من قراءة أي خاصية مثل length أو id أو استدعاء أي دالة حسابية، لأن المترجم لا يمتلك أي ضمان بأن النوع الذي سيمرره المستخدم يحتوي على تلك الخصائص. هنا تبرز الحاجة الملحة إلى قيود الأنواع العامة (Generic Constraints).

تشريح أنواع القيود في TypeScript

تسمح لنا القيود بحصر نطاق الأنواع المقبولة في معامل النوع T باستخدام الكلمة المفتاحية extends. نحن بذلك نقول للمترجم: “يمكن لـ T أن يكون أي نوع بشرط أن يحقق الهيكل الأدنى المحدد في القيد”. تنقسم القيود إلى عدة أنماط رئيسية:

1. القيد الهيكلي للواجهات (Interface & Structural Constraints)

يفرض هذا القيد أن يمتلك النوع T خصائص محددة مسبقاً، مثل اشتراط وجود دالة لحساب المساحة أو خاصية تعريفية:

interface Shape {
    name: string;
    calculateArea(): number;
    calculatePerimeter(): number;
}

interface Rectangle extends Shape {
    width: number;
    height: number;
}

interface Circle extends Shape {
    radius: number;
}

// دالة مقيدة تضمن أن T يمتلك خصائص واجهة Shape
function printShapeDetails<T extends Shape>(shape: T): void {
    console.log(`الشكل: ${shape.name}`);
    console.log(`المساحة: ${shape.calculateArea()}`);
    console.log(`المحيط: ${shape.calculatePerimeter()}`);
}

const myCircle: Circle = {
    name: "دائرة هندسية",
    radius: 7,
    calculateArea: () => Math.PI * 49,
    calculatePerimeter: () => 2 * Math.PI * 7
};

printShapeDetails(myCircle); // يمر بنجاح تام

2. قيد مفاتيح الكائنات باستخدام المعامل keyof (Index Type Constraints)

من أقوى أنماط القيود في TypeScript هو استخدام K extends keyof T، والذي يضمن أن المعامل الثاني يمثل مفتاحاً حقيقياً وموجوداً بالفعل داخل الكائن الأول، مما يمنع تمرير نصوص عشوائية قد تتسبب في قيمة undefined:

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
    return obj[key];
}

const systemUser = {
    id: "USR-882",
    username: "ahmed_dev",
    email: "ahmed@example.com",
    isActive: true
};

const userEmail = getProperty(systemUser, "email");     // النوع المستنتج هو string بدقة
const userStatus = getProperty(systemUser, "isActive"); // النوع المستنتج هو boolean بدقة

// ❌ خطأ ترجمة فوري: المفتاح غير موجود إطلاقاً داخل الكائن
// getProperty(systemUser, "phoneNumber"); 
// Argument of type '"phoneNumber"' is not assignable to parameter of type '"id" | "username" | "email" | "isActive"'.

3. قيود دوال البناء والإنشاء (Constructor & Newable Constraints)

عند بناء مصانع الكائنات أو أنماط حقن التبعيات (Dependency Injection)، نحتاج لتقييد النوع العام ليكون صنفاً قابلاً للاستدعاء بواسطة المعامل new:

type Constructor<T = {}> = new (...args: any[]) => T;

function createInstance<T>(ClassConstructor: new () => T): T {
    return new ClassConstructor();
}

class DatabaseConnection {
    public status = "Connected";
}

const db = createInstance(DatabaseConnection);
console.log(db.status); // Connected

الجزء الثالث: الشرح التفصيلي والخطوات العملية لبناء هياكل بيانات عامة

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

التطبيق العملي الأول: هيكل بيانات المكدس العام (Generic Stack Data Structure)

المكدس هو هيكل بيانات يعمل بمبدأ “ما يدخل آخراً يخرج أولاً” (LIFO: Last In, First Out). سنقوم بتصميمه ليعمل مع أي نوع من البيانات بأمان نوعي كامل:

class Stack<T> {
    private items: T[] = [];
    private readonly capacity: number;

    constructor(capacity: number = Infinity) {
        this.capacity = capacity;
    }

    public push(item: T): void {
        if (this.isFull()) {
            throw new Error("تجاوز سعة المكدس القصوى (Stack Overflow).");
        }
        this.items.push(item);
    }

    public pop(): T | undefined {
        if (this.isEmpty()) {
            throw new Error("المكدس فارغ تماماً (Stack Underflow).");
        }
        return this.items.pop();
    }

    public peek(): T | undefined {
        return this.items[this.items.length - 1];
    }

    public isEmpty(): boolean {
        return this.items.length === 0;
    }

    public isFull(): boolean {
        return this.items.length >= this.capacity;
    }

    public size(): number {
        return this.items.length;
    }
}

// تجربة المكدس مع الأرقام
const numberStack = new Stack<number>(5);
numberStack.push(10);
numberStack.push(20);
numberStack.push(30);
console.log(numberStack.pop()); // 30

التطبيق العملي الثاني: نمط مستودع البيانات المقيد (Generic Repository Pattern)

في تطبيقات المؤسسات وتطوير الواجهات الخلفية (Backend) وقواعد البيانات، يُعتبر نمط المستودع (Repository Pattern) المعيار الذهبي لعزل منطق الوصول للبيانات عن منطق الأعمال. هنا نفرض قيداً يلزم كل كيان بامتلاك حقل id:

interface BaseEntity {
    id: string | number;
    createdAt: Date;
    updatedAt: Date;
}

interface IRepository<T extends BaseEntity> {
    findById(id: T["id"]): T | null;
    findAll(): T[];
    save(entity: T): T;
    delete(id: T["id"]): boolean;
}

class InMemoryRepository<T extends BaseEntity> implements IRepository<T> {
    private storage: Map<T["id"], T> = new Map();

    public findById(id: T["id"]): T | null {
        return this.storage.get(id) || null;
    }

    public findAll(): T[] {
        return Array.from(this.storage.values());
    }

    public save(entity: T): T {
        entity.updatedAt = new Date();
        this.storage.set(entity.id, entity);
        return entity;
    }

    public delete(id: T["id"]): boolean {
        return this.storage.delete(id);
    }
}

// تعريف كيانات النظام
interface CustomerAccount extends BaseEntity {
    fullName: string;
    email: string;
    tier: "STANDARD" | "VIP";
}

// استخدام المستودع بأمان نوعي كامل
const customerRepo = new InMemoryRepository<CustomerAccount>();

const newCustomer: CustomerAccount = {
    id: "CUST-9001",
    fullName: "محمد أبو قشريف",
    email: "mohammad@code-elta6ur.com",
    tier: "VIP",
    createdAt: new Date(),
    updatedAt: new Date()
};

customerRepo.save(newCustomer);
const retrieved = customerRepo.findById("CUST-9001");
console.log(retrieved?.fullName); // محمد أبو قشريف

أفضل الممارسات والنصائح التطبيقية

بعد أن تعمقنا في فهم الفئات والقيود في سياق الأنواع العامة (Generics)، حان الوقت لاستكشاف أفضل الممارسات التي تفصل الكود المبتدئ عن البنى المعمارية الاحترافية:

• التسميات المعيارية ذات الدلالة: على الرغم من أن الحرف T هو المعيار العالمي للنوع العام (Type)، استخدم أحرفاً واضحة مثل K للمفاتيح (Keys)، و V للقيم (Values)، و E للعناصر (Elements)، و R لنتائج الدوال (Return Type). وإذا تعقدت الفئة وتضمنت أكثر من نوعين عامين، استخدم أسماء وصفية كاملة مثل <TEntity, TDto, TId>.
• القيم الافتراضية للأنواع العامة (Generic Type Defaults): يمكنك توفير نوع افتراضي يُستخدم في حال لم يحدده المطور صراحةً، تماماً كما تفعل مع المعاملات الافتراضية في الدوال:

  interface ApiResponse<TData = Record<string, unknown>> {
      status: number;
      message: string;
      payload: TData;
  }
  
  // يستخدم النوع الافتراضي التلقائي
  const defaultResponse: ApiResponse = {
      status: 200,
      message: "نجاح",
      payload: { key: "value" }
  };

• تجنب الإفراط في التعميم (Avoid Over-Genericizing): لا تجعل كل فئة وكل دالة عامة لمجرد إظهار البراعة التقنية. استخدم الأنواع العامة فقط عندما يكون الكود مكرراً بالفعل عبر أنواع متعددة أو عندما تبني مكوناً قابلاً لإعادة الاستخدام. إذا كانت الفئة ستتعامل دوماً مع User فقط، فاجعلها مخصصة له مباشرة.
• الجمع بين القيود وأنواع الاتحاد (Unions in Constraints): يمكنك تقييد النوع العام ليقبل فقط مجموعة محددة من الأنواع البدائية مثل <T extends string | number> لمنع تمرير الكائنات أو المصفوفات أو الدوال.
• تضييق النوع داخل الفئات العامة: عند التعامل مع حقول من نوع T، تذكر أنك قد تحتاج لاستخدام حراس الأنواع (Type Guards) مثل typeof أو instanceof إذا كان القيد يسمح بعدة أنواع متفرقة.

مقارنات وتحليلات متقدمة

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

1. مقارنة: Generics مقابل الواجهات المجردة مقابل any / unknown

2. قيود الأنواع العامة الديناميكية بواسطة الأنواع الشرطية (Conditional Generic Constraints)

يمكن دمج الأنواع العامة مع الأنواع الشرطية (Conditional Types) لإنشاء قيود ذكية تتغير سلوكياتها ونواتجها تلقائياً بناءً على النوع الممرر:

type Flatten<T> = T extends any[] ? T[number] : T;

// استخراج نوع العناصر الداخلية تلقائياً
type StrArray = Flatten<string[]>; // النوع الناتج: string
type PureNum = Flatten<number>;     // النوع الناتج: number

class DataExtractor<TInput> {
    constructor(private data: TInput) {}

    public extract(): Flatten<TInput> {
        if (Array.isArray(this.data)) {
            return this.data[0];
        }
        return this.data as Flatten<TInput>;
    }
}

const extractor = new DataExtractor(["كود", "التطور"]);
const firstItem = extractor.extract(); // string تلقائياً

حل المشكلات والأخطاء الشائعة في الفئات والقيود

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

المشكلة 1: Property does not exist on type ‘T’

الخطأ: محاولة الوصول إلى خاصية معينة داخل فئة عامة غير مقيدة، مثل this.data.id، فيرمي المترجم الخطأ: Property 'id' does not exist on type 'T'.

السبب والحل: المترجم لا يعلم ما إذا كان النوع T يمتلك هذا الحقل أم لا. الحل هو تقييد النوع فوراً باستخدام <T extends { id: string | number }> لإثبات وجود الخاصية للمترجم.

المشكلة 2: الأعضاء الثابتة والأنواع العامة (Static Members Cannot Reference Type Parameters)

الخطأ: محاولة تعريف خاصية أو دالة ثابتة داخل الفئة باستخدام معامل النوع الخاص بالفئة: static item: T;، مما ينتج الخطأ: Static members cannot reference class type parameters.

السبب والحل: الأعضاء الثابتة ترتبط بدالة بناء الفئة نفسها (Constructor Object) وتُهيأ مرة واحدة فقط في الذاكرة، بينما معاملات الأنواع T تُحدد لكل كائن (Instance) على حدة. لا يمكن للخاصية الثابتة أن تعرف أي نوع ستتبع. الحل هو إما جعل الدالة الثابتة تمتلك معامل نوع خاصاً بها مستقلاً تماماً:

class Container<T> {
    // ❌ خطأ فادح:
    // static defaultItem: T;

    // ✅ الحل الصحيح: دالة ثابتة عامة مستقلة
    public static createDefault<U>(value: U): Container<U> {
        return new Container<U>(value);
    }

    constructor(public value: T) {}
}

المشكلة 3: إنشاء كائنات جديدة من النوع العام مباشرة (Cannot use ‘new T()’)

الخطأ: محاولة كتابة const item = new T(); داخل الفئة العامة، مما يطلق الخطأ: 'T' only refers to a type, but is being used as a value here.

السبب والحل: الأنواع في TypeScript تُحذف بالكامل عند الترجمة (Type Erasure) ولا تترك أي كود حي في JavaScript. لا يمكن استدعاء new على نوع تم محوه. الحل هو تمرير دالة البناء (Constructor Function) كمعامل صريح لدالة الإنشاء كما وضحنا في قيود دوال البناء.

دراسات حالة وأمثلة واقعية متكاملة

لتطبيق هذه المعارف في بيئة تحاكي مشاريع الإنتاج الحقيقية، سنستعرض ثلاث دراسات حالة متكاملة تبرز القوة المعمارية للأنواع العامة المقيدة:

دراسة الحالة 1: محرك إدارة الأحداث المترابطة (Generic Type-Safe Event Emitter)

بناء نظام أحداث وملاحظات (Event Bus) يربط اسم الحدث بنوع البيانات الممررة معه بدقة تامة، ويمنع استدعاء أحداث وهمية أو تمرير بيانات خاطئة:

type EventMap = {
    userLoggedIn: { userId: string; timestamp: number };
    cartUpdated: { itemCount: number; totalValue: number };
    paymentCompleted: { transactionId: string; amount: number; success: boolean };
};

class TypedEventEmitter<TEvents extends Record<string, any>> {
    private listeners: {
        [K in keyof TEvents]?: Array<(payload: TEvents[K]) => void>;
    } = {};

    public on<K extends keyof TEvents>(eventName: K, handler: (payload: TEvents[K]) => void): void {
        if (!this.listeners[eventName]) {
            this.listeners[eventName] = [];
        }
        this.listeners[eventName]!.push(handler);
    }

    public emit<K extends keyof TEvents>(eventName: K, payload: TEvents[K]): void {
        const handlers = this.listeners[eventName];
        if (handlers) {
            handlers.forEach(fn => fn(payload));
        }
    }
}

// الاستخدام البرمجي العملي
const appEvents = new TypedEventEmitter<EventMap>();

appEvents.on("userLoggedIn", data => {
    console.log(`المستخدم ${data.userId} سجل دخوله بنجاح.`);
});

appEvents.emit("userLoggedIn", {
    userId: "USR-1029",
    timestamp: Date.now()
});

// ❌ خطأ ترجمة فوري لا يقبل التجاوز:
// appEvents.emit("userLoggedIn", { userId: "USR-10", extra: true }); // حقول غير مطابقة
// appEvents.emit("unknownEvent", {}); // حدث غير مسجل في الخريطة

دراسة الحالة 2: نظام استجابات الخدمات السحابية والشبكات (API Response Envelope)

نمذجة موحدة لكافة استجابات خوادم الويب تفصل بدقة بين حالات النجاح ذات البيانات المتغيرة، وبين رسائل الأخطاء القياسية مع دعم التصفح والترقيم (Pagination):

interface PaginationMetadata {
    currentPage: number;
    totalPages: number;
    pageSize: number;
    totalRecords: number;
}

class ServiceResult<TData, TError = string> {
    public readonly isSuccess: boolean;
    public readonly data?: TData;
    public readonly error?: TError;
    public readonly pagination?: PaginationMetadata;

    private constructor(isSuccess: boolean, data?: TData, error?: TError, pagination?: PaginationMetadata) {
        this.isSuccess = isSuccess;
        this.data = data;
        this.error = error;
        this.pagination = pagination;
    }

    public static success<T>(data: T, pagination?: PaginationMetadata): ServiceResult<T, never> {
        return new ServiceResult<T, never>(true, data, undefined, pagination);
    }

    public static failure<E>(error: E): ServiceResult<never, E> {
        return new ServiceResult<never, E>(false, undefined, error);
    }
}

// استهلاك النتيجة داخل طبقة التحكم (Controller Layer)
interface ArticleSummary {
    slug: string;
    views: number;
}

const successResult = ServiceResult.success<ArticleSummary[]>(
    [{ slug: "typescript-generics", views: 1540 }],
    { currentPage: 1, totalPages: 10, pageSize: 1, totalRecords: 10 }
);

if (successResult.isSuccess) {
    console.log(successResult.data?.map(a => a.slug));
}

الأسئلة الشائعة وإجاباتها التفصيلية

1. ما الفرق بين استخدام الواجهات (Interfaces) واستخدام قيود الأنواع العامة (Generic Constraints)؟

عندما تجعل دالة تقبل واجهة معينة مباشرة مثل function log(item: Printable): Printable، فإن نوع القيمة المرجعة سيقتصر دوماً على نوع الواجهة Printable فقط، وتفقد كافة الخصائص المحددة للكائن الفرعي الذي تم تمريره. أما عند استخدام القيد العام function log<T extends Printable>(item: T): T، فإنك تضمن وجود خصائص Printable مع الاحتفاظ الكامل بهوية النوع الأصلي الممرر وخصائصه الإضافية في القيمة المرجعة دون أي فقدان للمعلومات النوعية.

2. هل تؤثر الأنواع العامة وقيودها على سرعة وأداء تطبيق JavaScript في المتصفح؟

لا تؤثر على الإطلاق في وقت التشغيل (Runtime Performance). جميع الأقواس الزاوية <T> والقيود extends تُحذف تماماً بواسطة المترجم أثناء عملية التحويل إلى JavaScript (Type Erasure)، مما يعني أن ملف الإخراج النهائي لا يحمل أي وزن إضافي في الذاكرة ولا ينفذ أي تعليمات إضافية في المتصفح أو بيئة Node.js.

3. كيف يمكنني تطبيق قيود متعددة على نفس النوع العام؟

في TypeScript، لا يمكنك كتابة T extends A, B بصيغة الفواصل، ولكن يمكنك تحقيق ذلك بدمج الشروط والواجهات باستخدام نوع التقاطع (Intersection Type &) كالتالي: <T extends Serializable & Identifiable>. هذا يُلزم النوع T بتحقيق متطلبات الواجهتين معاً في آن واحد.

4. ما هو الفرق بين <T extends any> وترك <T> بدون قيد؟

من الناحية العملية، كلاهما يسمح بتمرير أي نوع بيانات. ولكن في سياقات متقدمة مثل الأنواع الشرطية (Conditional Types)، يُستخدم T extends any لفرض سلوك “التوزيع التلقائي للأنواع الاتحادية” (Distributive Conditional Types) عبر عناصر الاتحاد.

الخلاصة والخطوات القادمة

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

ملخص المكتسبات المعمارية:

• الفئات العامة (Generic Classes): توفر قوالب موحدة لهياكل البيانات (المكدس، الطابور، المستودعات) مع ثبات كامل لنوع المحتوى.
• القيود الهيكلية (Generic Constraints): استخدام extends لإثبات وجود خصائص معينة للمترجم وتجنب أخطاء وقت الترجمة.
• قيد المفاتيح (keyof Constraint): منع الأخطاء الإملائية وحماية الوصول لخصائص الكائنات بأمان نوعي كامل.
• الأنماط المؤسسية: توظيف نمط المستودع ومحركات الأحداث لبناء منصات متماسكة وسهلة الصيانة.

في الدروس القادمة، سننتقل إلى المرحلة الاحترافية التالية لاستكشاف الأنواع المخططة (Mapped Types) وأدوات التلاعب بالأنواع المدمجة (Utility Types) مثل Partial و Pick و Omit، لنتعلم كيف نشتق أنواعاً برمجية جديدة من أنواع قائمة بالفعل بأقل مجهود برمجي ممكن.

المراجع والمصادر الرسمية المعتمدة

• التوثيق الرسمي لـ TypeScript: الفئات العامة (Generic Classes)
• التوثيق الرسمي لـ TypeScript: قيود الأنواع العامة (Generic Constraints)
• التوثيق الرسمي لـ TypeScript: استخدام معاملات الأنواع في القيود مع keyof
• دورة TypeScript من الصفر إلى الاحتراف – منصة كود التطور