M

MLOG

العربية

أطلق العنان لقوة شروحات التباين وقيود معاملات النوع في TypeScript لإنشاء كود أكثر مرونة وأمانًا وقابلية للصيانة. تحليل معمق مع أمثلة عملية.

شروحات تباين TypeScript: إتقان قيود معاملات النوع لكود برمجي متين

TypeScript، وهي مجموعة شاملة من JavaScript، توفر الكتابة الساكنة (static typing)، مما يعزز موثوقية الكود وقابليته للصيانة. واحدة من الميزات المتقدمة والقوية في TypeScript هي دعمها لـ شروحات التباين (variance annotations) بالاقتران مع قيود معاملات النوع (type parameter constraints). فهم هذه المفاهيم أمر بالغ الأهمية لكتابة كود عام (generic) مرن ومتين حقًا. سيتعمق هذا المقال في التباين، والتباين المشترك، والتباين المعاكس، واللاتباين، موضحًا كيفية استخدام قيود معاملات النوع بفعالية لبناء مكونات أكثر أمانًا وقابلية لإعادة الاستخدام.

فهم التباين

يصف التباين كيف تؤثر علاقة النوع الفرعي (subtype) بين الأنواع على علاقة النوع الفرعي بين الأنواع المُنشأة (e.g., generic types). لنُفصّل المصطلحات الرئيسية:

من الأسهل تذكر ذلك من خلال تشبيه: تخيل مصنعًا يصنع أطواق الكلاب. قد يكون المصنع المتغاير (covariant) قادرًا على إنتاج أطواق لجميع أنواع الحيوانات إذا كان يستطيع إنتاج أطواق للكلاب، محافظًا على علاقة التوريث. المصنع المتباين عكسيًا (contravariant) هو الذي يمكنه *استهلاك* أي نوع من أطواق الحيوانات، بشرط أن يتمكن من استهلاك أطواق الكلاب. إذا كان المصنع لا يستطيع العمل إلا مع أطواق الكلاب ولا شيء آخر، فهو ثابت (invariant) بالنسبة لنوع الحيوان.

لماذا يهم التباين؟

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

// مثال JavaScript (توضيحي فقط، وليس TypeScript)
function modifyAnimals(animals, modifier) {
  for (let i = 0; i < animals.length; i++) {
    animals[i] = modifier(animals[i]);
  }
}

function sound(animal) { return animal.sound(); }

function Cat(name) { this.name = name; this.sound = () => "Meow!"; }
Cat.prototype = Object.create({ sound: () => "Generic Animal Sound"});
function Animal(name) { this.name = name; this.sound = () => "Generic Animal Sound"; }

let cats = [new Cat("Whiskers"), new Cat("Mittens")];

// هذا الكود سيُطلق خطأ لأن تعيين Animal إلى مصفوفة Cat غير صحيح
//modifyAnimals(cats, (animal) => new Animal("Generic")); 

// هذا يعمل لأن Cat تُعيّن إلى مصفوفة Cat
modifyAnimals(cats, (cat) => new Cat("Fuzzy"));

//cats.forEach(cat => console.log(cat.sound()));

على الرغم من أن مثال JavaScript هذا يوضح المشكلة المحتملة مباشرةً، فإن نظام الأنواع في TypeScript *يمنع* بشكل عام هذا النوع من التعيين المباشر. تصبح اعتبارات التباين مهمة في السيناريوهات الأكثر تعقيدًا، خاصة عند التعامل مع أنواع الدوال والواجهات العامة (generic interfaces).

قيود معاملات النوع

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

الكلمة المفتاحية extends

الطريقة الأساسية لتعريف قيود معاملات النوع هي باستخدام الكلمة المفتاحية extends. تحدد هذه الكلمة أن معامل النوع يجب أن يكون نوعًا فرعيًا من نوع معين.

function logName<T extends { name: string }>(obj: T): void {
  console.log(obj.name);
}

// استخدام صالح
logName({ name: "Alice", age: 30 });

// خطأ: الوسيط من النوع '{}' غير قابل للتعيين للمعامل من النوع '{ name: string; }'.
// logName({});

في هذا المثال، يتم تقييد معامل النوع T ليكون نوعًا يحتوي على خاصية name من النوع string. هذا يضمن أن الدالة logName يمكنها الوصول بأمان إلى الخاصية name للوسيط الخاص بها.

قيود متعددة مع أنواع التقاطع

يمكنك دمج قيود متعددة باستخدام أنواع التقاطع (&). هذا يسمح لك بتحديد أن معامل النوع يجب أن يلبي شروطًا متعددة.

interface Named {
  name: string;
}

interface Aged {
  age: number;
}

function logPerson<T extends Named & Aged>(person: T): void {
  console.log(`Name: ${person.name}, Age: ${person.age}`);
}

// استخدام صالح
logPerson({ name: "Bob", age: 40 });

// خطأ: الوسيط من النوع '{ name: string; }' غير قابل للتعيين للمعامل من النوع 'Named & Aged'.
// خاصية 'age' مفقودة في النوع '{ name: string; }' ولكنها مطلوبة في النوع 'Aged'.
// logPerson({ name: "Charlie" });

هنا، يتم تقييد معامل النوع T ليكون نوعًا يجمع بين Named و Aged. هذا يضمن أن الدالة logPerson يمكنها الوصول بأمان إلى كل من الخاصيتين name و age.

استخدام قيود النوع مع الفئات العامة

قيود النوع مفيدة بنفس القدر عند العمل مع الفئات العامة (generic classes).

interface Printable {
  print(): void;
}

class Document<T extends Printable> {
  content: T;

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

  printDocument(): void {
    this.content.print();
  }
}

class Invoice implements Printable {
  invoiceNumber: string;

  constructor(invoiceNumber: string) {
    this.invoiceNumber = invoiceNumber;
  }

  print(): void {
    console.log(`Printing invoice: ${this.invoiceNumber}`);
  }
}

const myInvoice = new Invoice("INV-2023-123");
const document = new Document(myInvoice);
document.printDocument(); // الناتج: Printing invoice: INV-2023-123

في هذا المثال، الفئة Document هي فئة عامة، ولكن معامل النوع T مقيد ليكون نوعًا يطبق الواجهة Printable. هذا يضمن أن أي كائن يستخدم كـ content في Document سيكون لديه دالة print. هذا مفيد بشكل خاص في السياقات الدولية حيث قد تتضمن الطباعة تنسيقات أو لغات متنوعة، مما يتطلب واجهة print مشتركة.

التباين المشترك، التباين المعاكس، واللاتباين في TypeScript (إعادة نظر)

على الرغم من أن TypeScript لا تحتوي على شروحات تباين صريحة (مثل in و out في بعض اللغات الأخرى)، إلا أنها تتعامل ضمنيًا مع التباين بناءً على كيفية استخدام معاملات النوع. من المهم فهم الفروق الدقيقة في كيفية عملها، خاصة مع معاملات الدوال.

أنواع معاملات الدوال: التباين المعاكس

أنواع معاملات الدوال متباينة عكسيًا. هذا يعني أنه يمكنك بأمان تمرير دالة تقبل نوعًا أعم من المتوقع. هذا لأنه إذا كانت الدالة تستطيع التعامل مع Supertype، فمن المؤكد أنها تستطيع التعامل مع Subtype.

interface Animal {
  name: string;
}

interface Cat extends Animal {
  meow(): void;
}

function feedAnimal(animal: Animal): void {
  console.log(`Feeding ${animal.name}`);
}

function feedCat(cat: Cat): void {
  console.log(`Feeding ${cat.name} (a cat)`);
  cat.meow();
}

// هذا صالح لأن أنواع معاملات الدوال متباينة عكسيًا
let feed: (animal: Animal) => void = feedCat; 

let genericAnimal:Animal = {name: "Generic Animal"};

feed(genericAnimal); // يعمل ولكنه لن يموي

let mittens: Cat = { name: "Mittens", meow: () => {console.log("Mittens meows");}};

feed(mittens); // يعمل أيضًا، وقد يموي اعتمادًا على الدالة الفعلية.

في هذا المثال، feedCat هو نوع فرعي من (animal: Animal) => void. هذا لأن feedCat يقبل نوعًا أكثر تحديدًا (Cat)، مما يجعله متباينًا عكسيًا بالنسبة لنوع Animal في معامل الدالة. الجزء الحاسم هو التعيين: let feed: (animal: Animal) => void = feedCat; صالح.

أنواع الإرجاع: التباين المشترك

أنواع الإرجاع في الدوال متغايرة. هذا يعني أنه يمكنك بأمان إرجاع نوع أكثر تحديدًا من المتوقع. إذا كانت الدالة تعد بإرجاع Animal، فإن إرجاع Cat مقبول تمامًا.

function getAnimal(): Animal {
  return { name: "Generic Animal" };
}

function getCat(): Cat {
  return { name: "Whiskers", meow: () => { console.log("Whiskers meows"); } };
}

// هذا صالح لأن أنواع الإرجاع في الدوال متغايرة
let get: () => Animal = getCat;

let myAnimal: Animal = get();

console.log(myAnimal.name); // يعمل

// myAnimal.meow();  // خطأ: الخاصية 'meow' غير موجودة في النوع 'Animal'.
// تحتاج إلى استخدام تأكيد النوع للوصول إلى الخصائص الخاصة بـ Cat

if ((myAnimal as Cat).meow) {
  (myAnimal as Cat).meow(); // Whiskers meows
}

هنا، getCat هو نوع فرعي من () => Animal لأنه يعيد نوعًا أكثر تحديدًا (Cat). التعيين let get: () => Animal = getCat; صالح.

المصفوفات والأنواع العامة: اللاتباين (في الغالب)

تعامل TypeScript المصفوفات ومعظم الأنواع العامة على أنها ثابتة (invariant) بشكل افتراضي. هذا يعني أن Array<Cat> *لا* يعتبر نوعًا فرعيًا من Array<Animal>، حتى لو كان Cat يرث من Animal. هذا خيار تصميمي متعمد لمنع الأخطاء المحتملة في وقت التشغيل. في حين أن المصفوفات *تتصرف* كما لو كانت متغايرة في العديد من اللغات الأخرى، فإن TypeScript تجعلها ثابتة من أجل الأمان.

let animals: Animal[] = [{ name: "Generic Animal" }];
let cats: Cat[] = [{ name: "Whiskers", meow: () => { console.log("Whiskers meows"); } }];

// خطأ: النوع 'Cat[]' غير قابل للتعيين للنوع 'Animal[]'.
// النوع 'Cat' غير قابل للتعيين للنوع 'Animal'.
// الخاصية 'meow' مفقودة في النوع 'Animal' ولكنها مطلوبة في النوع 'Cat'.
// animals = cats; // هذا قد يسبب مشاكل لو سُمح به!

// ولكن هذا سيعمل
animals[0] = cats[0];

console.log(animals[0].name);

//animals[0].meow();  // خطأ - يُنظر إلى animals[0] على أنه من النوع Animal لذا فإن meow غير متاح

(animals[0] as Cat).meow(); // يلزم تأكيد النوع لاستخدام دوال خاصة بـ Cat

السماح بالتعيين animals = cats; سيكون غير آمن لأنه يمكنك بعد ذلك إضافة Animal عام إلى مصفوفة animals، مما سينتهك أمان النوع لمصفوفة cats (التي من المفترض أن تحتوي على كائنات Cat فقط). لهذا السبب، تستنتج TypeScript أن المصفوفات ثابتة.

أمثلة عملية وحالات استخدام

نمط المستودع العام (Generic Repository Pattern)

فكر في نمط مستودع عام للوصول إلى البيانات. قد يكون لديك نوع كيان أساسي وواجهة مستودع عامة تعمل على هذا النوع.

interface Entity {
  id: string;
}

interface Repository<T extends Entity> {
  getById(id: string): T | undefined;
  save(entity: T): void;
  delete(id: string): void;
}

class InMemoryRepository<T extends Entity> implements Repository<T> {
  private data: { [id: string]: T } = {};

  getById(id: string): T | undefined {
    return this.data[id];
  }

  save(entity: T): void {
    this.data[entity.id] = entity;
  }

  delete(id: string): void {
    delete this.data[id];
  }
}

interface Product extends Entity {
  name: string;
  price: number;
}

const productRepository: Repository<Product> = new InMemoryRepository<Product>();

const newProduct: Product = { id: "123", name: "Laptop", price: 1200 };
productRepository.save(newProduct);

const retrievedProduct = productRepository.getById("123");
if (retrievedProduct) {
  console.log(`Retrieved product: ${retrievedProduct.name}`);
}

يضمن قيد النوع T extends Entity أن المستودع لا يمكنه العمل إلا على الكيانات التي لها خاصية id. يساعد هذا في الحفاظ على سلامة البيانات واتساقها. هذا النمط مفيد لإدارة البيانات بتنسيقات مختلفة، والتكيف مع التدويل من خلال التعامل مع أنواع عملات مختلفة ضمن واجهة Product.

معالجة الأحداث مع حمولات عامة

حالة استخدام شائعة أخرى هي معالجة الأحداث. يمكنك تحديد نوع حدث عام بحمولة محددة.

interface Event<T> {
  type: string;
  payload: T;
}

interface UserCreatedEventPayload {
  userId: string;
  email: string;
}

interface ProductPurchasedEventPayload {
  productId: string;
  quantity: number;
}

function handleEvent<T>(event: Event<T>): void {
  console.log(`Handling event of type: ${event.type}`);
  console.log(`Payload: ${JSON.stringify(event.payload)}`);
}

const userCreatedEvent: Event<UserCreatedEventPayload> = {
  type: "user.created",
  payload: { userId: "user123", email: "alice@example.com" },
};

const productPurchasedEvent: Event<ProductPurchasedEventPayload> = {
  type: "product.purchased",
  payload: { productId: "product456", quantity: 2 },
};

handleEvent(userCreatedEvent);
handleEvent(productPurchasedEvent);

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

بناء خط أنابيب عام لتحويل البيانات

فكر في سيناريو تحتاج فيه إلى تحويل البيانات من تنسيق إلى آخر. يمكن تنفيذ خط أنابيب عام لتحويل البيانات باستخدام قيود معاملات النوع لضمان توافق أنواع الإدخال والإخراج مع دوال التحويل.

interface DataTransformer<TInput, TOutput> {
  transform(input: TInput): TOutput;
}

function processData<TInput, TOutput, TIntermediate>(
  input: TInput,
  transformer1: DataTransformer<TInput, TIntermediate>,
  transformer2: DataTransformer<TIntermediate, TOutput>
): TOutput {
  const intermediateData = transformer1.transform(input);
  const outputData = transformer2.transform(intermediateData);
  return outputData;
}

interface RawUserData {
  firstName: string;
  lastName: string;
}

interface UserData {
  fullName: string;
  email: string;
}

class RawToIntermediateTransformer implements DataTransformer<RawUserData, {name: string}> {
    transform(input: RawUserData): {name: string} {
        return { name: `${input.firstName} ${input.lastName}`};
    }
}

class IntermediateToUserTransformer implements DataTransformer<{name: string}, UserData> {
    transform(input: {name: string}): UserData {
        return {fullName: input.name, email: `${input.name.replace(" ", ".")}@example.com`};
    }
}

const rawData: RawUserData = { firstName: "John", lastName: "Doe" };

const userData: UserData = processData(
  rawData,
  new RawToIntermediateTransformer(),
  new IntermediateToUserTransformer()
);

console.log(userData);

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

أفضل الممارسات والاعتبارات

الخلاصة

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