Ալգորիթմների կառուցումը տիպերի մակարդակում TypeScript-ում
Մտածո՞ւմ եք սկսել type-level ծրագրավորում։ Այս գրառումը ձեզ կծանոթացնի հիմնարար տեխնիկաներին, որոնք թույլ են տալիս իրականացնել գրեթե ցանկացած ալգորիթմ՝ օգտագործելով միայն TypeScript-ի տիպերը։
Իհարկե, սովորական ծրագրավորումը հաճելի է, բայց երբևէ գրե՞լ եք տիպեր, որոնք բառացիորեն ավելի ծանր հաշվարկներ են կատարում, քան սովորական to-do հավելվածը։ Ցավալիորեն երկար build-եր, զրո կողմնակի էֆեկտ, խրթին շարահյուսություն և թիմակիցների զարմացած մեկնաբանություններ ձեր PR-ների տակ՝ բարի գալուստ type-level ծրագրավորողի աշխարհ։
Ցանկանո՞ւմ եք հաստատուն ժամանակով bubble sort։ Կամ տիպերից կառուցված ինտերպրետատոր։ Այս գրառման մեջ ես ձեզ կծանոթացնեմ հիմնարար տեխնիկաներին, որոնք թույլ են տալիս իրականացնել գրեթե ցանկացած ալգորիթմ՝ օգտագործելով միայն TypeScript-ի տիպերը։
Նկատի ունեցեք, որ գրառումը բավական երկար է և շոշափում է բազմաթիվ առանձին TypeScript հնարավորություններ։ Այն մեկ նստքով կարդալու փոխարեն կարող եք ավելացնել էջանիշերում և վերադառնալ, երբ հարմար լինի։
Ի՞նչ է պահանջում ծրագրավորումը
Եթե թվարկեմ լեզվի այն տարրերը, որոնք առօրյա ծրագրավորման մեջ ինձ ամենաօգտակարն են թվում, կստացվի սա.
- տվյալների կառուցվածքներ
- ֆունկցիաներ
- պայմաններ/կոդի ճյուղավորում
- ցիկլեր
- հիմնական հանրահաշիվ (թվեր, գումարում, բազմապատկում և այլն)
Եթե կարծում եք, որ վերը նշված ցանկը բավական է ցանկացած բան ծրագրավորելու համար, հիանալի է, որովհետև ես ցույց կտամ, թե ինչպես կարելի է դրանցից յուրաքանչյուրը նմանակել միայն տիպերով։ Ահա կարճ ակնարկ.
- տվյալների կառուցվածքներ → օբյեկտային և tuple տիպեր
- ֆունկցիաներ → generic տիպեր
- պայմաններ/կոդի ճյուղավորում → պայմանական տիպեր
- ցիկլեր → ռեկուրսիվ տիպեր
- հիմնական հանրահաշիվ (թվեր, գումարում, բազմապատկում և այլն) → վերը նշված տեխնիկաների համադրում tuple-ների երկարությունների խելացի օգտագործմամբ
Տվյալների կառուցվածքներ/օբյեկտային և tuple տիպեր
Այս մասը բավական պարզ է։ Նայեք, թե որքան նման են TS օբյեկտները օբյեկտային տիպերին.
const someObj = {
a: "foo",
b: { bar: "baz" },
c: 42,
};
type someType = {
a: "foo",
b: { bar: "baz" },
c: 42,
};
Այստեղ բարդ ոչինչ չկա։ Նկատեք, թե որքան նման են TS օբյեկտները օբյեկտային տիպերին.
Տարբերությունն այն է, որ someType-ի դաշտերի «արժեքները» իրականում տիպեր են, որոնք պարզապես նման են TypeScript-ի արժեքների։ Դա այն պատճառով է, որ TypeScript-ում 42-ի նման հաստատունը կա՛մ արժեք է, կա՛մ տիպ՝ կախված այն բանից, թե որտեղ է հայտնվում։
Այս հարմար հատկությունը, որ հայտնի է որպես literal տիպեր, հենց այն է, ինչը հնարավոր է դարձնում տիպերի մակարդակում որևէ հետաքրքիր բան գրել։ Առանց դրա մենք կունենայինք միայն number կամ string նման տիպեր, որոնք շատ ավելի քիչ ճշգրիտ են և, արդյունքում, շատ ավելի քիչ արտահայտիչ։
Հաջորդ բաժիններում ներկայացված են type օբյեկտների հետ աշխատելու մի քանի օգտակար եղանակներ։
Հատկությունների ընթերցում
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
Նկատեք, որ օբյեկտի բոլոր արժեքների տիպերի միավորումը ստանալու այս տեխնիկան կարելի է վերածել generic տիպի (որպեսզի այն աշխատի ցանկացած օբյեկտային տիպի համար).
type ValueOf<T> = T[keyof T]; // more about generic types in the next section
type UserValue = ValueOf<User>;
// ^ string | number | boolean
Օբյեկտների միավորում
Օբյեկտները կարելի է միավորել հատման (intersect) տիպով (&)։ Եկեք ավելի մոտիկից նայենք, թե ինչպես է այն աշխատում.
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; }
Հիմա անցնենք tuple-ներին. ահա դրանց մի քանի հետաքրքիր հատկություններ։
Տարրերի ընթերցում
Tuple-ի տարրերին դիմելը աշխատում է հենց այնպես, ինչպես օբյեկտների դեպքում արեցինք.
type SomeTuple = [string, number, boolean];
type First = SomeTuple[0]; // string
type Second = SomeTuple[1]; // number
type Tail = SomeTuple[1 | 2]; // number | boolean
Միակ տարբերությունն այն է, որ բոլոր տարրերի միավորումը ստանալու համար ավելի լավ է tuple-ը ինդեքսավորել number-ով, այլ ոչ թե keyof SomeTuple-ով։ Վերջինս մեզ կտար նաև բոլոր հատկությունները, որ TypeScript-ի զանգվածները կրում են, ինչպիսիք են length, map և այլն, ինչը սովորաբար մեզ պետք չէ.
type AllKeys = SomeTuple[number]; // string | number | boolean
Tuple-ների միացում
Ինչպես արժեքների մակարդակի TS-ում, tuple-ները կարելի է միացնել spread օպերատորով.
type SomeTuple = [1, 2, 3];
type AnotherTuple = [4, 5, 6];
type Concatenated = [...SomeTuple, ...AnotherTuple];
// ^ [1, 2, 3, 4, 5, 6]
Ֆունկցիաներ/generic տիպեր
Կրկին այս բաժինը կսկսեմ արհեստական օրինակով, որտեղ JS ֆունկցիաները և TS generic տիպերը զարմանալիորեն նման են.
// value-level JavaScript
const makeTuple = (a, b) => [a, b];
// type-level TypeScript
type makeTuple<a, b> = [a, b];
Անկյունավոր փակագծերում գտնվող փոփոխականները սովորաբար կոչվում են type պարամետրեր, և, ինչպես սովորական ֆունկցիաների դեպքում, դրանք կարող են օգտագործվել աջ կողմում. ամեն անգամ, երբ այս տիպը «կանչվում» է կոնկրետ տիպերով, type պարամետրերը փոխարինվում են դրանցով և հաշվարկվում է կոնկրետ տիպ։
type double<T> = [T, T];
type doubleString = double<string> // [string, string]
type doubleNubmer = double<number> // [number, number]
Առանց generic-ների մեզ կպահանջվեր առանձին double տիպ յուրաքանչյուր տիպի համար, որը կուզեինք օգտագործել։
Սակայն սպասեք՝ արդյո՞ք generic տիպերը միշտ պետք է գրվեն այնպես, որ ընդունեն ցանկացած տիպ։ Բարեբախտաբար՝ ոչ. types constraints կոչվող մեխանիզմը թույլ է տալիս նեղացնել տիպերի այն բազմությունը, որը կարելի է փոխանցել մեր generic-ին.
type MakeTuple<T extends number, U extends string> = [T, U];
type x = MakeTuple<42, "foo">; // OK
type badUsage = makeTuple<"foo", "bar">; // Error!
Generic տիպերն ունեն մի քանի սահմանափակում.
- Բարձր կարգի generic տիպերը հնարավոր չեն, այսինքն՝ generic տիպը չի կարող ընդունել կամ վերադարձնել մեկ այլ generic տիպ։
- Generic տիպի ամբողջ «մարմինը» պետք է լինի մեկ արտահայտություն, այլ ոչ թե հրահանգների հաջորդականություն, ինչպես արժեքների մակարդակի 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-ի եռակի (ternary) օպերատորին։ Հիմնական տարբերությունն այն է, որ առաջին մասը պետք է լինի extends արտահայտություն, այլ ոչ թե բուլյան արժեք։ Պարզ ասած՝ extends-ը ստուգում է, թե արդյոք առաջին տիպը երկրորդի ենթատիպն է։ Վերևի օրինակում մենք ստուգում ենք, թե արդյոք generic 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-ում ներդրված եռակի օպերատորները համարվում են հակաօրինաչափություն (anti-pattern), քանի որ վնասում են ընթեռնելիությանը, բայց type-level ծրագրավորման մեջ այլընտրանք չկա, ուստի պարզապես պետք է հաշտվենք դրանց հետ։
type And<A extends boolean, B extends boolean> = A extends true
? B extends true
? true
: false
: false;
Infer հիմնաբառը
Պայմանական տիպերում extends հիմնաբառը թույլ է տալիս ստուգել, թե արդյոք generic տիպը համապատասխանում է տրված ձևին։ 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
- Մենք սահմանում ենք օրինաչափություն, որի հետ ստուգվում է generic արգումենտը։
inferհիմնաբառերը տեղադրում ենք օրինաչափության այն մասերում, որոնք ուզում ենք պահել փոփոխականներում։- Երբ type արգումենտը համապատասխանում է օրինաչափությանը, վերցրած փոփոխականները դառնում են մեզ հասանելի։
Ցիկլեր/ռեկուրսիվ տիպեր
Տիպերի մակարդակում ցիկլերի աջակցություն չկա, բայց ռեկուրսիան կարելի է օգտագործել իտերացիա պահանջող ցանկացած տրամաբանություն իրականացնելու համար։ Ռեկուրսիվ տիպը սովորաբար հետևում է այս գաղափարին.
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>>;
Ռեկուրսիվ տիպերը հաճախ օգտագործվում են tuple-ում կամ տողում ինչ-որ բան որոնելու համար։ Որպես օրինակ՝ ահա թե ինչպես կարելի է հանել ճանապարհանման տողի վերջին տարրը.
type ExtractLastItem<Path extends string> =
Path extends `${string}/${infer Rest}`
? ExtractLastItem<Rest>
: Path;
type Item = ExtractLastItem<"foo/bar/baz/hello">;
// ^ "hello"
Յուրաքանչյուր իտերացիայի ժամանակ մենք փորձում ենք ճանապարհը բաժանել առաջին /-ի մոտ։ Եթե դա հաջողվում է, տիպը ռեկուրսիվ կերպով կիրառում ենք ճանապարհի՝ առաջին /-ից հետո գտնվող մասի վրա։ Բազային դեպքին հասնում ենք, երբ ճանապարհը այլևս / չի պարունակում։ Այդ պահին մենք գտել ենք վերջին տարրը, ուստի վերադարձնում ենք այն, և ռեկուրսիան կանգ է առնում։
Հիմնական հանրահաշիվ
TypeScript-ը պաշտոնապես չի աջակցում թվաբանություն type-level թվերի վրա։ Այնուամենայնիվ, սա ծրագրավորողներին չի խանգարում չարաշահել tuple-ների length հատկությունը՝ գոնե բնական թվերի հանրահաշիվը նմանակելու համար։ Ահա հնարքը։
type len = [1, 2, 3, 4]["length"]
// ^ 4 🤯
Հենց այդպես։ Կարող էիք սպասել, որ length հատկությունը պարզապես կտիպավորվի որպես number։ Սակայն քանի որ tuple-ների երկարությունները հայտնի են կոմպիլյացիայի ժամանակ, TypeScript-ը կարողանում է ավելի ճշգրիտ լինել։
Ահա երկու թվերի՝ a-ի և b-ի գումարման բաղադրատոմսը, որն օգտագործում է այս վարքը.
- կառուցել
aերկարությամբ tuple - կառուցել
bերկարությամբ tuple - միացնել երկուսը
- կարդալ ստացված tuple-ի
lengthհատկությունը
Կոդով այն ունի այսպիսի տեսք.
type Add<A extends number, B extends number> = Length<
Concat<CreateArrOfLen<A>, CreateArrOfLen<B>>
>;
Հատկությունների ընթերցումը և tuple-ների միացումը մենք արդեն քննարկել ենք, ուստի մնում է միայն կոնկրետ երկարության tuple կառուցելը։ Այստեղ ընտրության մեծ հնարավորություն չկա. ռեկուրսիան է ճանապարհը.
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 տիպերը :)
Շնորհակալություն կարդալու համար։ Եթե ձեզ դուր եկավ type-level ծրագրավորման այս ներածությունը, տեղեկացրեք մեզ և անպայման բաժանորդագրվեք մեր բլոգին՝ այսպիսի ավելի շատ գրառումների համար 👍🏻