4 քիչ հայտնի TypeScript խորհուրդ, որոնք կբարելավեն ձեր մշակողի փորձը
TypeScript-ը շատ ավելին է առաջարկում, քան ֆունկցիաների արգումենտների տիպերի նշումը։ Այս բլոգային գրառումը ներկայացնում է TypeScript-ի քիչ տարածված տեխնիկաների և հնարավորությունների հետաքրքիր կիրառություններ, այդ թվում՝ տիպերի մակարդակի ծրագրավորում, generic-ներ և branded տիպեր։
TypeScript-ը շատ ավելին է առաջարկում, քան ֆունկցիաների արգումենտների տիպերի նշումը։ Այս գրառման մեջ կուսումնասիրենք TypeScript-ի քիչ տարածված տեխնիկաների և հնարավորությունների որոշ հետաքրքիր կիրառություններ, այդ թվում՝ տիպերի մակարդակի ծրագրավորում, generic-ներ և branded տիպեր։
1. Հնարավորության դեպքում նոր տիպեր ածանցեք՝ պատճենելու փոխարեն
Պատկերացրեք՝ մեր հավելվածը մշակում է գործարքներ և աջակցում է 3 արժույթի։ Մեր օգնական ֆունկցիաները ավելի ճշգրիտ տիպավորելու համար կարող ենք սահմանել այդ արժույթների union տիպ՝
type Currency = "EUR" | "USD" | "GBP";
function currencyToSymbol(currency: Currency): string {
switch (currency) {
case "EUR":
return "€";
case "USD":
return "$";
case "GBP":
return "£";
}
}
Առայժմ ամեն ինչ լավ է։ Այս տիպի շնորհիվ ստանում ենք հարմար ինքնալրացում, և TypeScript-ը համոզվում է, որ բոլոր հնարավոր դեպքերը ծածկված են։ Խնդիրներ են սկսվում, երբ պետք է UI տարր, որը թույլ է տալիս օգտատիրոջը ընտրել արժույթ՝
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 => {
// ...
}
Այս մոտեցումն ունի բազմաթիվ թերություններ։ Ամենաակնհայտը այս տիպը ձեռքով փոխակերպելու և գրելու ձանձրալի աշխատանքն է, ինչից ծրագրավորողները փորձում են խուսափել։ Կարող էինք դա թողնել արհեստական բանականությանը, բայց դա մեկ այլ խնդիր կառաջացներ՝ ավելորդություն։ Երբ API-ն փոխվի, պետք է հիշենք տիպը թարմացնել երկու տեղում։
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-ի ներկառուցված տիպերի օգտագործումը
Ստորև բերված են ևս մի քանի ներկառուցված generic տիպեր, որոնք օգտակար են այլ տիպեր ածանցելու համար՝
- Awaited – ռեկուրսիվ կերպով բացում է Promise-ները, օրինակ՝
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. Գեներացրեք տիպերը անմիջապես ձեր backend-ից
Ինչպե՞ս կարող ենք արտաքին REST API-ների հետ հաղորդակցությունը դարձնել տիպային առումով անվտանգ։
Փոքր նախագծերի համար կամ երբ REST API-ն պարզ է և անփոփոխ է մնում, fetch ֆունկցիաները ինքներս տիպավորելը լավ է։ Սակայն ակտիվ զարգացման մեջ գտնվող նախագծում հոգնեցուցիչ է դառնում API-ի տիպերը ձեռքով թարմացնել փոփոխությունների մատյանների կամ, ավելի վատ, թիմակիցների slack հաղորդագրությունների հիման վրա։
Կոդի գեներացիան ելքերից մեկն է։ Տիպային աշխատանքային ընթացքն այսպիսի տեսք ունի՝
- Backend թիմը մեզ տալիս է OpenAPI սխեմա JSON կամ Yaml ֆայլով, որը սովորաբար գեներացվում է նրանց սկզբնական կոդից։
- Frontend թիմը վերագեներացնում է տիպերը այնպիսի գործիքով, ինչպես openapi-typescript-ը կամ dtsgenerator-ը։
- Վերջում նրանք գործարկում են տիպերի ստուգում՝ գտնելու շտկման կարիք ունեցող ցանկացած կոտրող փոփոխություն։
Լիովին տիպավորված React hook-երի գեներացիա
Երբ React-ն օգտագործում եք react-query-ի հետ, կարող եք մի քայլ ավելի առաջ գնալ և գեներացնել ոչ միայն տիպեր, այլ նաև լիովին տիպավորված react-query hook-եր։ 🤯 Դրա համար կարող եմ խորհուրդ տալ 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 տիպեր
Մեր հավելվածները երբեմն աշխատում են արժեքների հետ, որոնք կազմում են ներկառուցված պրիմիտիվ տիպի կոնկրետ ենթաբազմություններ։ Օրինակ՝ email-ները, 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);
}
Միայն տիպերը չեն կարող երաշխավորել, որ արգումենտն իսկապես պարզ թիվ է։ Մտքով գալիս են երկու պարզ լուծում՝
- Յուրաքանչյուր ֆունկցիայի սկզբում դնել assertion-ներ (
isPrime)։ - Մեկ անգամ main-ում ստուգել, որ
arg-ը պարզ է, և օգնական ֆունկցիաներին թողնել «վստահել», որ ստանում են պարզ թիվ։
Առաջին տարբերակի առավելությունն այն է, որ ծրագիրը մնում է անվտանգ՝ ինչպես էլ վերադասավորենք այս օգնականների շուրջ կոդը։ Այն նաև օգնական ֆունկցիաները պահում է մաքուր և վերօգտագործելի, քանի որ նրանց ճշտությունը չի հենվում մի ենթադրության վրա, որը հնարավոր չէ ստուգել կոմպիլյացիայի ժամանակ։
Երկրորդ տարբերակը, մյուս կողմից, մեզ խնայում է ավելորդ assertion-ներից, որոնք այստեղ կարող են բավական թանկ հաշվարկվել։
Իսկ եթե ասեմ, որ TypeScript-ի քիչ տարածված տեխնիկան թույլ է տալիս երկու մոտեցումների առավելություններն էլ ստանալ միաժամանակ։ 😊
Խնդրի լուծումը branded տիպերով
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
Հաջորդը կարող ենք գրել assertion ֆունկցիա, որը ստուգում է՝ արդյոք թիվը պարզ է, և դա արտահայտում է տիպի մակարդակում՝
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 👍🏻
Մեր սկզբնական օրինակն այժմ կարելի է վերաշարադրել branded տիպերով՝
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. Օգտագործեք generic-ներ 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-ին՝ կոմպիլյատորին ասելու համար «ես ավելի լավ գիտեմ, քան դու»։ Սակայն դա ավելացնում է խոսունություն, և եթե իրականացումը հետագայում փոխվի, կարող ենք հայտնվել runtime սխալի առաջ։
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-ի generic-ները թույլ են տալիս այս կոմպոնենտին ստիպել վարվել հենց այնպես, ինչպես նախատեսված է։
Սկզբում հայտարարում ենք T տիպի փոփոխական, որը կարող է լինել ցանկացած տիպ՝ պայմանով, որ այն ընդլայնում է { id: string; name: string } ձևը, այսինքն՝ պարունակում է առնվազն այս երկու դաշտերը, բայց կարող է ավելին էլ պարունակել։
const GenericList = <T extends { id: string; name: string }>(...) => {
...
};
Հետո T-ն փոխանցում ենք GenericListsProps-ին՝ options prop-ի տիպը 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>
);
};
Շնորհակալություն կարդալու համար։ Այս տեխնիկաներից որևէ մեկը ձեզ առանձնապես հետաքրքիր թվա՞ց։ Օգտվո՞ւմ եք դրանցից ձեր առօրյա կոդավորման մեջ։ Պատմեք մեզ և բաժանորդագրվեք մեր բլոգին՝ առաջիկա ավելի շատ front-end գրառումների համար։