بناء الخوارزميات على مستوى الأنواع في TypeScript
هل تفكر في دخول عالم البرمجة على مستوى الأنواع؟ يرشدك هذا المقال عبر التقنيات الأساسية التي تتيح لك تنفيذ أي خوارزمية تقريبًا باستخدام أنواع TypeScript وحدها.
بالطبع، البرمجة العادية ممتعة، لكن هل كتبت يومًا أنواعًا تُجري حرفيًا حسابات أثقل من تطبيق قائمة المهام المعتاد؟ عمليات بناء طويلة بشكل مؤلم، ولا آثار جانبية، وصياغة غامضة، وتعليقات محيّرة من زملائك على طلبات الدمج (PR) – مرحبًا بك في عالم مبرمج مستوى الأنواع.
هل تريد فرز فقاعات (bubble sort) بزمن ثابت؟ أو مفسّرًا مبنيًا من الأنواع؟ في هذا المقال سأرشدك عبر التقنيات الأساسية التي تتيح لك تنفيذ أي خوارزمية تقريبًا باستخدام أنواع TypeScript وحدها.
ضع في اعتبارك أن المقال طويل نسبيًا ويتناول ميزات TypeScript منفصلة كثيرة. فبدلًا من قراءته في جلسة واحدة، قد تفضّل حفظه في المفضلة والعودة إليه متى شئت.
ماذا تتطلب البرمجة؟
إذا سردت عناصر اللغة التي أراها الأكثر فائدة في البرمجة اليومية، فسأصل إلى ما يلي:
- هياكل البيانات
- الدوال
- الشروط/تفرّع الشيفرة
- الحلقات
- الجبر الأساسي (الأعداد، الجمع، الضرب، إلخ)
إذا كنت تعتقد أن القائمة أعلاه تكفي لبرمجة أي شيء – فهذا رائع، لأنني سأبيّن كيف يمكن محاكاة كل واحد منها بالأنواع وحدها! وهذه لمحة سريعة:
- هياكل البيانات ← أنواع الكائنات وأنواع الصفوف (tuples)
- الدوال ← الأنواع العامة (generic types)
- الشروط/تفرّع الشيفرة ← الأنواع الشرطية (conditional types)
- الحلقات ← الأنواع التعاودية (recursive types)
- الجبر الأساسي (الأعداد، الجمع، الضرب، إلخ) ← مزج التقنيات أعلاه مع استخدام ذكي لأطوال الصفوف
هياكل البيانات/أنواع الكائنات والصفوف
هذا الجزء بسيط جدًا. انظر كم تشبه كائنات TS أنواع الكائنات:
const someObj = {
a: "foo",
b: { bar: "baz" },
c: 42,
};
type someType = {
a: "foo",
b: { bar: "baz" },
c: 42,
};
لا شيء معقد هنا. لاحظ كم تشبه كائنات TS أنواع الكائنات:
الفرق أن «قيم» الحقول في someType هي في الواقع أنواع تشبه قيم TypeScript فقط. وذلك لأن ثابتًا مثل 42 في TypeScript هو إما قيمة وإما نوع، بحسب المكان الذي يظهر فيه.
هذه الميزة المفيدة، المعروفة بالأنواع الحرفية (literal types)، هي ما يجعل من الممكن كتابة أي شيء مثير للاهتمام على مستوى الأنواع أصلًا. فبدونها لن يكون لدينا سوى أنواع مثل number أو string، وهي أقل دقة بكثير، وبالتالي أقل تعبيرًا بكثير.
تعرض الأقسام التالية بعض الطرق المفيدة للتعامل مع أنواع الكائنات.
قراءة الخصائص
type User = { name: string; age: number; isAdmin: boolean };
type Name = User["name"];
// ^ string
// User.name doesn't work
type ValueOf<T> = T[keyof T];
type UserValue = ValueOf<User>;
// ^ string | number | boolean
على مستوى القيم، يتيح لنا TS استخدام صياغة النقطة، مثل user.name، أو صياغة الأقواس المربعة، مثل user["name"]، لكن على مستوى الأنواع يبدو أن صياغة الأقواس فقط هي المتاحة. والمفارقة المثيرة أن الأقواس تحتوي نوعًا لا مجرد اسم حقل كسلسلة نصية. وكل مفتاح يطابق ذلك النوع يسهم بنوعه المقابل في النتيجة:
type NameOrAge = User["age" | "name"];
// ^ string | number 🤯
type UserKeys = keyof User;
// ^ "name" | "age" | "isAdmin"
type UserValues = User[UserKeys];
// ^ string | number | boolean
لاحظ أن هذه التقنية للحصول على اتحاد (union) لأنواع جميع قيم الكائن يمكن تحويلها إلى نوع عام (ليعمل مع أي نوع كائن):
type ValueOf<T> = T[keyof T]; // more about generic types in the next section
type UserValue = ValueOf<User>;
// ^ string | number | boolean
دمج الكائنات
يمكن دمج الكائنات بنوع التقاطع (&). لننظر إليه عن قرب لنرى كيف يعمل:
type I = A & B;
يمكن قراءة السطر أعلاه هكذا: «I من النوع A والنوع B في وقت واحد». وبعبارة أخرى، يمكن إسناد متغير من النوع I إلى متغير من النوع A وإلى متغير من النوع B معًا.
حين يكون A وB كائنين، فما هو النوع «الأصغر» الذي يحقق هذا الشرط؟ كائن يحتوي كل حقول A وB! وما دامت الحقول لا تتعارض (مثلًا يكون لكل من A وB مفتاح “foo” لكن بنوعين مختلفين)، فهذا يعادل فعليًا الدمج!
type WithName = { name: string };
type WithAge = { age: number };
type WithIsAdmin = { isAdmin: boolean };
type User = WithName & WithAge & WithIsAdmin;
// ^ { name: string; age: number; isAdmin: boolean; }
type Org = WithName & WithAge;
// ^ { name: string; age: number; }
الأنواع المساعدة Pick وOmit
تتصرف هذه الأنواع المدمجة مثل نظيراتها على مستوى القيم التي اشتهرت بها مكتبات مثل lodash أو ramda. والفرق – كما خمّنت على الأرجح – أن وسائطها يمكن أن تكون أي أنواع لا السلاسل النصية فقط:
type User = { name: string; age: number; isAdmin: boolean };
type JustNameAndAge = Pick<User, "name" | "age">;
// ^ { name: string; age: number; }
type WithoutName = Omit<User, "name">;
// ^ { age: number; isAdmin: boolean; }
والآن إلى الصفوف (tuples) – وهذه بعض خصائصها المثيرة للاهتمام.
قراءة العناصر
الوصول إلى عناصر الصف يعمل تمامًا مثل ما فعلنا مع الكائنات:
type SomeTuple = [string, number, boolean];
type First = SomeTuple[0]; // string
type Second = SomeTuple[1]; // number
type Tail = SomeTuple[1 | 2]; // number | boolean
الفرق الوحيد أنه للحصول على اتحاد جميع العناصر، من الأفضل فهرسة الصف بـ number بدلًا من keyof SomeTuple. فالأخير سيعطينا أيضًا كل خاصية تحملها مصفوفات TypeScript، مثل length وmap وغيرهما، وهذا عادةً ليس ما نريده:
type AllKeys = SomeTuple[number]; // string | number | boolean
دمج الصفوف
كما في TS على مستوى القيم، يمكن دمج الصفوف باستخدام عامل النشر (spread):
type SomeTuple = [1, 2, 3];
type AnotherTuple = [4, 5, 6];
type Concatenated = [...SomeTuple, ...AnotherTuple];
// ^ [1, 2, 3, 4, 5, 6]
الدوال/الأنواع العامة
مرة أخرى، سأفتتح هذا القسم بمثال مصطنع تتشابه فيه دوال JS والأنواع العامة في TS تشابهًا لافتًا:
// value-level JavaScript
const makeTuple = (a, b) => [a, b];
// type-level TypeScript
type makeTuple<a, b> = [a, b];
تسمى المتغيرات داخل الأقواس الزاوية عادةً معاملات النوع (type parameters)، وكما في الدوال العادية يمكن استخدامها في الطرف الأيمن؛ وكل مرة «يُستدعى» فيها هذا النوع بأنواع محددة، تُستبدل معاملات النوع بها ويُحسب نوع ملموس.
type double<T> = [T, T];
type doubleString = double<string> // [string, string]
type doubleNubmer = double<number> // [number, number]
ومن دون الأنواع العامة، سنحتاج إلى نوع double منفصل لكل نوع نريد استخدامه!
لكن مهلًا – هل يجب دائمًا كتابة الأنواع العامة بحيث تقبل كل نوع؟ لحسن الحظ لا: ما يُسمى قيود الأنواع (types constraints) يتيح لنا تضييق مجموعة الأنواع التي يمكن تمريرها إلى النوع العام:
type MakeTuple<T extends number, U extends string> = [T, U];
type x = MakeTuple<42, "foo">; // OK
type badUsage = makeTuple<"foo", "bar">; // Error!
تأتي الأنواع العامة مع بعض القيود:
- الأنواع العامة من الرتبة العليا غير ممكنة، أي أن النوع العام لا يستطيع قبول نوع عام آخر أو إرجاعه.
- يجب أن يكون «جسم» النوع العام بأكمله تعبيرًا واحدًا، لا سلسلة من العبارات كما في TypeScript على مستوى القيم.
تفرّع الشيفرة/الأنواع الشرطية (+ infer)
تتيح لنا الأنواع الشرطية محاكاة التفرع if/else. على سبيل المثال:
type isString<T> = T extends string ? true : false;
type res1 = isString<"ala">; // true
type res2 = isString<42>; // false
لكل نوع شرطي ثلاثة أجزاء: شرط، وحالة if، وحالة else:
type isString<T> = T extends string ? true : false;
// ^^^^^^^^^^^^^^^^ ^^^^ ^^^^^
// condition if else
مظهره وسلوكه شبيهان تقريبًا بالعامل الثلاثي في JavaScript. والفرق الأساسي أن الجزء الأول يجب أن يكون تعبير extends لا قيمة منطقية. وببساطة، يختبر extends ما إذا كان النوع الأول نوعًا فرعيًا من الثاني. وفي المثال أعلاه نختبر ما إذا كان النوع العام T نوعًا فرعيًا من string. ولمحاكاة العامل الثلاثي على مستوى الأنواع، يمكننا وضع extends true في الشرط:
type BadIf<Cond extends boolean, Then, Else> = Cond ? Then : Else; // WON'T WORK
type GoodIf<Cond extends boolean, Then, Else> = Cond extends true ? Then : Else;
type example = GoodIf<true, 42, 0>; // 42
في JavaScript العادية تُعدّ العوامل الثلاثية المتداخلة نمطًا سيئًا لأنها تضر بقابلية القراءة، لكن في البرمجة على مستوى الأنواع لا يوجد بديل، لذا علينا أن نتعايش معها.
type And<A extends boolean, B extends boolean> = A extends true
? B extends true
? true
: false
: false;
الكلمة المفتاحية infer
في الأنواع الشرطية، تتيح لنا الكلمة المفتاحية extends اختبار ما إذا كان نوع عام يطابق شكلًا معينًا. وبـ infer يمكننا التقاط أجزاء من ذلك الشكل في متغير واستخدامها في الفرع `then’.
لنستعرض مثالًا:
// check if T matches this pattern
// vvvvvvvvvvvvvvvvvvvvvvvvvvvv
type GetNestedProp<T> = T extends { a: { b: { c: infer C } } } ? C : never;
// ^^^^^^^^^^^
// if it does then capture this part as a variable
// ^^^^^
// use it in the then branch
type a = GetNestedProp<{ a: { b: { c: "hello" } } }>;
// ^ "hello"
type b = GetNestedProp<boolean>;
// ^ never, because the boolean doesn't match our pattern
- نعرّف نمطًا يُفحص الوسيط العام مقابله.
- نضع الكلمات المفتاحية
inferفي أجزاء النمط التي نريد تخزينها في متغيرات. - عندما يطابق وسيط النوع النمط، تصبح المتغيرات الملتقطة متاحة لنا.
الحلقات/الأنواع التعاودية
لا يدعم مستوى الأنواع الحلقات، لكن يمكن استخدام التعاود (recursion) لتنفيذ أي منطق يحتاج إلى تكرار. ويتبع النوع التعاودي عمومًا هذه الفكرة:
type SomeRecursiveType<Arg> =
// check if we reached the end of the iteration
CheckBaseCase<Arg> extends true
// if yes, then "return" something
? SomeType<Arg>
// else, use recursive type again, but with a different argument
: SomeRecursiveType<ModifyArg<Arg>>;
تُستخدم الأنواع التعاودية كثيرًا للبحث عن شيء في صف أو سلسلة نصية. وكمثال، إليك كيفية استخراج العنصر الأخير من سلسلة نصية على هيئة مسار.
type ExtractLastItem<Path extends string> =
Path extends `${string}/${infer Rest}`
? ExtractLastItem<Rest>
: Path;
type Item = ExtractLastItem<"foo/bar/baz/hello">;
// ^ "hello"
في كل تكرار نحاول تقسيم المسار عند أول /. فإذا نجح ذلك، نطبق النوع تعاوديًا على الجزء من المسار الذي يلي أول /. وتُبلغ الحالة الأساسية حين لا يحتوي المسار على أي /. عندها نكون قد وجدنا العنصر الأخير، فنعيده ويتوقف التعاود.
الجبر الأساسي
لا يدعم TypeScript رسميًا العمليات الحسابية على الأعداد على مستوى الأنواع. ومع ذلك لا يمنع هذا المبرمجين من إساءة استخدام الخاصية length للصفوف لمحاكاة جبر الأعداد الطبيعية على الأقل. إليك الحيلة.
type len = [1, 2, 3, 4]["length"]
// ^ 4 🤯
بالضبط! ربما تتوقع أن تُكتب الخاصية length ببساطة كـ number. لكن بما أن أطوال الصفوف معروفة وقت الترجمة، يستطيع TypeScript أن يكون أدق.
وهذه وصفة جمع عددين، a وb، تستغل هذا السلوك:
- ابنِ صفًا بطول
a - ابنِ صفًا بطول
b - ادمج الصفين
- اقرأ الخاصية
lengthللصف الناتج
وفي الشيفرة يبدو ذلك هكذا:
type Add<A extends number, B extends number> = Length<
Concat<CreateArrOfLen<A>, CreateArrOfLen<B>>
>;
سبق أن تناولنا قراءة الخصائص ودمج الصفوف، فلم يتبقَّ سوى بناء صف بطول محدد. ليس هناك خيار كبير هنا – التعاود هو السبيل:
type Append<T extends any[], U> = [...T, U];
type CreateArrOfLen<
N extends number,
CurrArr extends any[] = []
> = CurrArr["length"] extends N
? CurrArr
: CreateArrOfLen<N, Append<CurrArr, any>>;
وبجمع كل القطع نحصل على هذا:
type Append<T extends any[], U> = [...T, U];
type CreateArrOfLen<
N extends number,
CurrArr extends any[] = []
> = CurrArr["length"] extends N
? CurrArr
: CreateArrOfLen<N, Append<CurrArr, any>>;
type Concat<A extends any[], B extends any[]> = [...A, ...B];
type Length<T extends any[]> = T["length"] extends number
? T["length"]
: never;
type Add<A extends number, B extends number> = Length<
Concat<CreateArrOfLen<A>, CreateArrOfLen<B>>
>;
طرح B من A أصعب قليلًا. الأسلوب هو مطابقة مصفوفة بطول A مع شكل مصفوفة بحجم B مدموجة مع مصفوفة أخرى U، ثم إرجاع طول U.
// A = 5, B = 3
// [any, any, any, any, any]
// ^^^^^^^^^^^^^^|^^^^^^^^^
// B U
// ^^^^^^^^^^^^^^^^^^^^^^^^
// A
type Sub<A extends number, B extends number> = CreateArrOfLen<A> extends [
...CreateArrOfLen<B>,
...infer U,
]
? Length<U>
: 0;
وللبقاء ضمن الأعداد الطبيعية، نعيد 0 كلما طُرح عدد أكبر من عدد أصغر. لذا فما نفذناه فعليًا هو max(0, sub(a,b)).
تمرين للقارئ: جرّب تنفيذ النوعين Multiply وDivide :)
شكرًا لقراءتك! إذا أعجبتك هذه المقدمة في البرمجة على مستوى الأنواع، فأخبرنا، واشترك في مدونتنا لتصلك مقالات أخرى مثل هذا 👍🏻