4 نصائح قليلة الشهرة في TypeScript تحسّن تجربتك كمطوّر
تقدّم TypeScript أكثر بكثير من مجرد تعليقات الأنواع على وسائط الدوال. يعرض هذا المقال تطبيقات مثيرة للاهتمام لتقنيات وميزات أقل شعبية في TypeScript، منها البرمجة على مستوى الأنواع (type-level programming) والأنواع العامة (generics) والأنواع الموسومة (branded types).
تقدّم TypeScript أكثر بكثير من مجرد تعليقات الأنواع على وسائط الدوال. سنستكشف في هذا المقال بعض التطبيقات المثيرة للاهتمام لتقنيات وميزات أقل شعبية في TypeScript، منها البرمجة على مستوى الأنواع (type-level programming) والأنواع العامة (generics) والأنواع الموسومة (branded types).
1. اشتقّ أنواعًا جديدة بدل النسخ واللصق كلما أمكن
تخيّل أن تطبيقنا يتعامل مع معاملات مالية ويدعم 3 عملات. ولتحديد أنواع دوالنا المساعدة بدقة أكبر، قد نعرّف نوعًا اتحاديًا (union type) من هذه العملات:
type Currency = "EUR" | "USD" | "GBP";
function currencyToSymbol(currency: Currency): string {
switch (currency) {
case "EUR":
return "€";
case "USD":
return "$";
case "GBP":
return "£";
}
}
حتى الآن كل شيء على ما يرام. بهذا النوع نحصل على إكمال تلقائي مفيد، وتتأكد TypeScript من تغطية كل حالة ممكنة. تبدأ المشكلة عندما نحتاج إلى عنصر واجهة يتيح للمستخدم اختيار عملة:
const CurrencySelector = () => (
<select>
{["EUR", "USD", "GBP"].map((currency) => (
<option value={currency}>{currency}</option>
))}
</select>
);
هذا بعيد عن المثالية. يمكننا إخراج الـ tuple من المكوّن وتحديد نوعه بـ Currency[]، لكن سيظل علينا إبقاؤه متزامنًا مع النوع Currency يدويًا كلما تغيّر. تزول كل هذه المشكلات بمجرد أن نشتق النوع Currency من tuple ثابت:
const currencies = ["EUR", "USD", "PLN"] as const;
type Currency = typeof currencies[number];
// ^ "EUR" | "USD" | "PLN"
البرمجة على مستوى الأنواع
حسنًا، لنجرّب شيئًا أصعب.
تخيّل واجهة برمجية (API) تعيد استجابة من هذا النوع:
type RawResponse = {
last_edit: string;
items: {
content: string;
column_idx: number;
selected_color: string;
}[];
}
لكن تطبيقنا يستخدم camelCase، فنحوّل الاستجابة إلى كائن جديد بأسماء حقول مطابقة:
type Response = {
lastEdit: string;
items: {
content: string;
columnIdx: number;
selectedColor: string;
}[];
}
const mapResponseToCamelCase = (resp: RawResponse): Response => {
// ...
}
لهذا النهج سلبيات كثيرة. أوضحها المهمة المملة المتمثلة في تحويل هذا النوع وكتابته يدويًا – وهو أمر يحاول المبرمجون تجنبه. يمكننا تكليف الذكاء الاصطناعي بذلك، لكن هذا سيُدخل مشكلة مختلفة: التكرار. فكلما تغيّرت الواجهة البرمجية، سيلزمنا تذكّر تحديث النوع في مكانين.
يمكن لدعم TypeScript القوي للبرمجة على مستوى الأنواع إصلاح كل ذلك. لنكتب نوعًا يقبل أي نوع بصيغة snake case ويحوّله إلى ما يكافئه بصيغة camel case:
type SnakeToCamel<T> = T extends `${infer part}_${infer Rest}`
? `${part}${Capitalize<SnakeToCamel<Rest>>}`
: T;
type example1 = SnakeToCamel<"hello">; // "hello"
type example2 = SnakeToCamel<"hello_world">; // "helloWorld"
type DeepSnakeToCamel<T> = T extends any[]
? { [K in keyof T]: DeepSnakeToCamel<T[K]> }
: {
[K in keyof T as SnakeToCamel<K>]: DeepSnakeToCamel<
T[K]
>;
};
type example3 = DeepSnakeToCamel<{
foo: { foo_bar: string; foo_bar_baz?: { bar: string } };
}>;
/* ^
{
foo: {
fooBar: string;
fooBarBaz?: {
bar: string;
};
};
}
*/
من الآن فصاعدًا، يمكن أن يكون RawResponse المصدر الوحيد للحقيقة، وتُشتق منه الأنواع الأخرى:
type Response = DeepSnakeToCamel<RawResponse>;
const mapResponseToCamelCase = (resp: RawResponse): Response = {
// ...
}
استخدام الأنواع المضمّنة في TypeScript
فيما يلي بضعة أنواع عامة مضمّنة أخرى مفيدة لاشتقاق أنواع أخرى:
- Awaited – يفكّ غلاف الـ Promises بشكل تكراري، مثل
Awaited<Promise<string>> -> string
type unwrapped = Awaited<Promise<string>>;
// ^ string
type BlogPost = {
title: string;
author: Author;
content: string;
}
type BlogPostPreview = Pick<BlogPost, "title" | "author">
// ^ { title: string; author: Author; }
// same as:
type BlogPostPreview2 = Omit<BlogPost, "content">;
type A = Exclude<"a" | "b" | "c", "a" | "b">;
// ^ "c"
type B = Extract<"a" | "b" | "c", "a" | "f">;
// ^ "a"
- Parameters وReturnValue – يستخرجان، على التوالي، أنواع معاملات دالة أو نوع قيمتها المعادة، على سبيل المثال:
type params = Parameters<(a: string, b: number) => void>;
// ^ [string, number]
type retVal = ReturnValue<(a: string, b: number) => void>;
// ^ void
2. ولّد الأنواع مباشرة من الواجهة الخلفية
كيف يمكننا جعل التواصل مع واجهات REST الخارجية آمنًا من حيث الأنواع؟
في المشاريع الصغيرة، أو عندما تكون واجهة REST بسيطة وثابتة، لا بأس بأن نحدد أنواع دوال الجلب (fetch) بأنفسنا. أما في مشروع قيد التطوير النشط، فيصبح تحديث أنواع الواجهة يدويًا استنادًا إلى سجلات التغيير أو – وهو الأسوأ – رسائل slack من الزملاء أمرًا مرهقًا.
توليد الشيفرة أحد المخارج. ويبدو سير العمل المعتاد هكذا:
- يسلّمنا فريق الواجهة الخلفية مخطط OpenAPI في ملف JSON أو Yaml، يُولَّد عادةً من شيفرتهم المصدرية.
- يعيد فريق الواجهة الأمامية توليد الأنواع بأداة مثل openapi-typescript أو dtsgenerator.
- وأخيرًا، يشغّلون فحص أنواع للعثور على أي تغييرات كاسرة تحتاج إلى إصلاح.
توليد React hooks مكتملة الأنواع
عند استخدام React مع react-query، يمكنك الذهاب خطوة أبعد وتوليد لا الأنواع فحسب، بل أيضًا hooks مكتملة الأنواع لـ react-query! 🤯 ولهذا أوصي بـ openapi-codegen:
import { useListPets } from "./petStore/petStoreComponents"; // <- output from openapi-codegen
const Example = () => {
const { data, loading, error } = useListPets();
// `data` is fully typed and have all documentation from OpenAPI
};
يمكن العثور على مزيد من التفاصيل في هذا المقال.
وبالطبع يتوقف كل شيء على جودة مخطط OpenAPI. فإن اعتمد على أنواع عامة فقط (مثل string بدلًا من “option1” | “option2”) أو لم يفصل بين الحقول الإلزامية والاختيارية، ضاعت معظم المزايا.
3. الأنواع الموسومة (Branded types)
تعمل تطبيقاتنا أحيانًا مع قيم تشكّل مجموعات فرعية محددة من نوع أولي مضمّن. فالبريد الإلكتروني وعناوين url أو صيغ معرّفات (ID) معينة، مثلًا، مجموعات فرعية من النوع string، بينما الأعداد الفردية والصحيحة والأولية مجموعات فرعية من النوع number. ومع أن نظام الأنواع في TypeScript تعبيري، فله حدوده أيضًا :)
المشكلة
لنفترض أننا نبني برنامجًا يعمل مع الأعداد الأولية. ولإبقائه مقروءًا، كتبنا عدة دوال مساعدة صغيرة تقبل عددًا أوليًا وسيطًا وتجري عليه بعض الحسابات. لكن بالنظر إلى البرنامج ككل، نقرأ عددًا أوليًا واحدًا ثم نمرّره عبر هذه الدوال.
const doStuffWithPrime1 = (prime: number) => { /* ... */ }
const doStuffWithPrime2 = (prime: number) => { /* ... */ }
const doStuffWithPrime3 = (prime: number) => { /* ... */ }
const main = (arg: number) => {
const res1 = doStuffWithPrime1(arg);
const res2 = doStuffWithPrime2(arg);
const res3 = doStuffWithPrime3(arg);
console.log("results: ", res1, res2, res3);
}
لا تستطيع الأنواع وحدها ضمان أن الوسيط عدد أولي فعلًا. يخطر ببالنا حلان بسيطان:
- وضع تأكيدات (
isPrime) في بداية كل دالة. - التحقق مرة واحدة في main من أن
argعدد أولي، وترك الدوال المساعدة «تثق» بأنها تستقبل عددًا أوليًا.
ميزة الخيار الأول أن البرنامج يبقى آمنًا مهما أعدنا ترتيب الشيفرة حول هذه الدوال المساعدة. كما يُبقي الدوال المساعدة نقية وقابلة لإعادة الاستخدام، لأن صحتها لا تعتمد على افتراض لا يمكن التحقق منه وقت الترجمة.
أما الخيار الثاني فيوفر علينا تأكيدات زائدة، قد يكون حسابها هنا مكلفًا نسبيًا.
فماذا لو قلت لك إن تقنية أقل شعبية في TypeScript تتيح لنا الحصول على مزايا النهجين معًا؟ 😊
حل المشكلة بالأنواع الموسومة
في TypeScript، يؤدي تعريف النوع Prime بالشكل type Prime = number إلى مجرد اسم مستعار (alias) لا يمكن تمييزه عن النوع الموجود على الجانب الأيمن. وهذا يعني أن Prime يمكن استخدامه أينما كان العدد متوقعًا، والعكس صحيح.
type Prime = number;
declare function fun(p: Prime): void;
// this should error but it doesn't
const someNum: number = 2;
fun(someNum);
fun(42);
أما إذا كتبنا بدلًا من ذلك:
type Prime = number & { readonly _brand: unique symbol };
فإننا نحصل على نوع متميز مرتبط بمعرّف النوع Prime هذا تحديدًا.
type Prime = number & { readonly _brand: unique symbol };
declare function fun(p: Prime): void;
const someNum: number = 2;
fun(someNum); // this results in TS error 🥳
fun(42); // this as well
بعد ذلك، يمكننا كتابة دالة تأكيد تتحقق مما إذا كان العدد أوليًا وتعبّر عن ذلك على مستوى الأنواع:
function assertIsPrime (num: number): asserts num is Prime {
/* put real implementation here... */
if (num !== 2) {
throw new Error("the number is not prime");
}
}
const someNum: number = 2;
assertIsPrime(someNum); // after this line someNum will be inferred to be `Prime`
fun(someNum); // it type checks!
fun(2); // this errors, because `2` is inferred as number so it can't be passed
// to a function that requires an argument of `Prime` type 👍🏻
يمكننا الآن إعادة كتابة مثالنا الأول بالأنواع الموسومة:
type Prime = number & { readonly _brand: unique symbol };
function assertIsPrime (num: number): asserts num is Prime {
/* put real implementation here... */
if (num !== 2) {
throw new Error("the number is not prime");
}
}
const doStuffWithPrime1 = (prime: Prime) => { /* ... */ }
const doStuffWithPrime2 = (prime: Prime) => { /* ... */ }
const doStuffWithPrime3 = (prime: Prime) => { /* ... */ }
const main = (arg: number) => {
assertIsPrime(arg);
const res1 = doStuffWithPrime1(arg);
const res2 = doStuffWithPrime2(arg);
const res3 = doStuffWithPrime3(arg);
console.log("results: ", res1, res2, res3);
}
4. استخدم الأنواع العامة (generics) في مكوّنات React
لنفترض أن تطبيقنا يحتوي هذين النوعين:
type User = {
id: string;
name: string;
role: 'admin' | 'client';
joinedAt: Date;
};
type Item = {
id: string;
name: string;
size: 'small' | 'medium' | 'large';
};
في بعض أجزاء التطبيق نحتاج إلى عرض قائمة مستخدمين، وفي أخرى قائمة عناصر. يمكننا كتابة مكوّنين منفصلين UsersList وItemsList، لكن بما أن القائمتين متطابقتان في الشكل والسلوك، فقد يكون نهج مختلف أفضل. أحد الخيارات مكوّن واحد يقبل أي شيء له name وid:
type ListProps = {
options: { name: string; id: string }[];
onChange: (x: { name: string; id: string }) => void;
};
const List = ({ options, onChange }: ListProps) => {
return (
<select
onChange={(e) => onChange(options.find((el) => el.id === e.target.value))}
>
{options.map((el) => (
<option value={el.id}>{el.name}</option>
))}
</select>
);
};
ولأن كلا النوعين يحتويان هذين الحقلين، يمكن تمرير أي منهما إلى المكوّن List، ويبدو أنه يعمل.
const users: User[] = [
{
id: 'aaa',
name: 'John',
role: 'admin',
joinedAt: new Date(2023, 5, 7),
},
{
id: 'bbb',
name: 'Mark',
role: 'client',
joinedAt: new Date(2023, 5, 7),
},
{
id: 'ccc',
name: 'Matt',
role: 'client',
joinedAt: new Date(2023, 5, 7),
},
];
const items: Item[] = [
{
id: 'ddd',
name: 'Table',
size: 'small',
},
{
id: 'eee',
name: 'Chair',
size: 'medium',
},
{
id: 'fff',
name: 'Bed',
size: 'large',
},
];
export default function App() {
return (
<div>
<h1>Hello</h1>
<List options={users} onChange={(x) => console.log(x)} />
<List options={items} onChange={(x) => console.log(x)} />
</div>
);
}
للأسف، هناك مشكلة. فمهما مررنا إلى المكوّن، يُحدَّد نوع وسيط onChange فيه دائمًا بـ { id: string; name: string; }، مع أن نحن نعرف نوعه الفعلي.
يمكن للمبرمجين اللجوء إلى as في مثل هذه الحالات لإخبار المترجم «أنا أعرف أفضل منك». لكن ذلك يزيد الإسهاب، وإذا تغيّر التنفيذ لاحقًا، فقد ينتهي بنا الأمر إلى خطأ وقت التشغيل.
export default function App() {
return (
<div>
<h1>Hello</h1>
<List options={users} onChange={(x) => someOperationOnUser(x as User)} />
<List options={items} onChange={(x) => someOperationOnItem(x as Item)} />
</div>
);
}
لحسن الحظ، تتيح لنا الأنواع العامة في TypeScript جعل هذا المكوّن يتصرف تمامًا كما نريد.
في البداية، نعلن متغير نوع T قد يكون أي نوع، شريطة أن يمتد الشكل { id: string; name: string } – أي أن يحتوي هذين الحقلين على الأقل لكن يجوز أن يحتوي المزيد.
const GenericList = <T extends { id: string; name: string }>(...) => {
...
};
ثم نمرّر T إلى GenericListsProps لربط نوع الخاصية options بـ onChange. وبهذه الطريقة نعبّر عن أنه، أيًّا كان T، فإن options مصفوفة منه، وonChange دالة من T إلى void.
type GenericListProps<T> = {
options: T[];
onChange: (x: T) => void;
};
const GenericList = <T extends { id: string; name: string }>({
options,
onChange,
}: GenericListProps<T>) => {
...
};
يبقى جسم المكوّن دون تغيير. لنستخدم الآن المكوّن في تطبيقنا ونشاهد كيف تُستنتج الأنواع!
type GenericListProps<T> = {
options: T[];
onChange: (x: T) => void;
};
const GenericList = <T extends { id: string; name: string }>({
options,
onChange,
}: GenericListProps<T>) => {
return (
<select
onChange={(e) => onChange(options.find((el) => el.id === e.target.value))}
>
{options.map((el) => (
<option value={el.id}>{el.name}</option>
))}
</select>
);
};
شكرًا على القراءة! هل كانت أي من هذه التقنيات مثيرة لاهتمامك بوجه خاص؟ وهل تعتمد عليها في برمجتك اليومية؟ أخبرنا، واشترك في مدونتنا لمزيد من المقالات عن الواجهة الأمامية قريبًا.