Առաջադեմ տիպային մակարդակի թվաբանություն TypeScript-ում, մաս 1՝ իրականացումը
Տեսեք, թե ինչպես կառուցել `Add` և `Subtract` գործողություններ, որոնք գոյություն ունեն զուտ տիպերի մակարդակում և հաշվարկվում են կոմպիլյացիայի ժամանակ։
Եթե կարդացել եք TypeScript-ի մասին իմ նախորդ հոդվածները, արդեն գիտեք, որ լեզուն ունի ուշագրավ արտահայտիչ տիպային համակարգ։ Լավ օգտագործելու դեպքում այն կարող է այդպիսի մանրակրկիտ տիպավորված կոդի հետ աշխատող յուրաքանչյուրին տալ բոլորովին նոր մակարդակի developer փորձառություն։
Սակայն երկու մասից բաղկացած այս բլոգ շարքում մենք կկենտրոնանանք մի բանի վրա, որը առանձնապես գործնական չէ, բայց զվարճալի է և հիանալի մարզում է մեր «տիպավորման մկանները»։ Մենք կկառուցենք Add և Subtract գործողություններ, որոնք աշխատում են զուտ տիպերի մակարդակում և հետևաբար հաշվարկվում են կոմպիլյացիայի ժամանակ։
type res = Add<16, 4>;
// ^ 20
Ամենալավն այն է, որ, ի տարբերություն «Basic algebra» մոտեցման, որ ես ներկայացրել էի նախկինում, տիպերը, որոնք մենք պատրաստվում ենք գրել, կարող են գումարել և հանել և՛ բացասական, և՛ դրական թվեր՝ մինչև 9007199254740991 (Number.MAX_SAFE_INTEGER) սահմանը 🤯։
Add<-123, -52>; // -175
Add<123, -52>; // 71
Add<-123, 52> // -71
Add<123456789, 9988776655>; // 10112233444
Add<9007199254740989, 2>; // 9007199254740991
Ինչպես ես հանգեցի դրան
Իմ լուծումը սկզբում ոգեշնչված էր MinusOne type challenge-ով։
Ի դեպ, եթե չգիտեք Type Challenges-ի մասին, դա տիպային զվարճալի հանելուկների բաց կոդով հավաքածու է։ Դրանց միջով անցնելը TypeScript-ի կախարդ դառնալու հիանալի (և դժվար) ճանապարհ է։
Այդ խնդրի թեստային դեպքերից մեկը ակնկալում էր, որ լուծումը 0-ից հանի 1 և ստանա -1։ Սա տեսնելը ինձ զարմացրեց, քանի որ ես հավատում էի, որ բացասական թվերը չեն կարող մշակվել տիպերի մակարդակում, քանի որ tuple-ների երկարությունները չեն կարող դրանք արտահայտել։ Հետաքրքրությունից դրդված՝ ես անցա լուծումների միջով և գտա այս մեկը։
Երկար պատմությունը կարճ՝ հնարքը string-ներն էին։ Դա տրամաբանական է, քանի որ TypeScript-ի ներկառուցված գործիքները string տիպերի հետ աշխատելու համար բավական զարգացած են, և, ինչպես պարզեցի, string տիպը կարելի է վերլուծել թվային տիպի այսպես՝
type ParseInt<T extends string>
= T extends `${infer Digit extends number}`
// ^^^^^^^^^^^^^^
// key element
? Digit
: never;
type example = ParseInt<"42">; // 42 (not "42" 👍🏻)
Սա հնարավոր է սկսած TypeScript 4.8-ից։
MinusOne տիպը հասկանալը
Այս գրառման մեջ մենք կդիտարկենք, թե ինչպես է աշխատում MinusOne տիպը, և կկառուցենք նմանատիպ PlusOne տիպ։ Հաջորդ գրառման մեջ մենք այդ գաղափարը ավելի առաջ կտանենք և դրա հիման վրա կկառուցենք ամբողջական Add և Subtract տիպեր։
Բարձր մակարդակում MinusOne ալգորիթմը հետևյալն է՝
- Արգումենտը դարձնել string
Երբ այն դրական է, մենք string-ների մշակման միջոցով կառուցում ենք string, որը ներկայացնում է մեկով նվազեցված թիվը
Երբ այն բացասական է, մենք հանում ենք մինուս նշանը, կառուցում ենք string, որը ներկայացնում է մեկով ավելացված թիվը, և նշանը վերադարձնում ենք
- Ստացված string-ը նորից դարձնել թիվ։
Սկսենք մի քանի օժանդակ տիպերից՝
type ReverseString<S extends string> = S extends `${infer First}${infer Rest}`
? `${ReverseString<Rest>}${First}`
: "";
type RemoveLeadingZeros<S extends string> = S extends "0"
? S
: S extends `0{infer R}`
? RemoveLeadingZeros<R>
: S;
type PutSign<S extends string> = `-${S}`;
Այս օգնական տիպերը ունեն նկարագրական անուններ և բավական պարզ են։ Այնուամենայնիվ, եթե դրանց իրականացման եղանակը ձեզ անծանոթ է, փորձեք որոնել այս տեխնիկաները՝
- “TypeScript infer in Template String Types”
- “TypeScript recursive types”։
Այնուհետև ուսումնասիրենք InternalMinusOne-ը՝ կենտրոնական տիպը, որն իրականում կատարում է թվից մեկ հանելու աշխատանքը։
// `S` is a reversed string representing some number, e.g., "0321" instead of 1230
type InternalMinusOne<S extends string> =
S extends `${infer Digit extends number}${infer Rest}`
? Digit extends 0
? `9${InternalMinusOne<Rest>}`
: `${[9, 0, 1, 2, 3, 4, 5, 6, 7, 8][Digit]}${Rest}`
: never;
Այն աշխատում է շատ նման երկար հանմանը, որ սովորել եք տարրական դպրոցում։ Վերցնում ենք վերջին թվանշանը (որը այստեղ առաջինն է, քանի որ թիվը շրջված է) և մշակում ենք երկու դեպք՝
- Երբ
dթվանշանը 0 չէ, մենք այն փոխարինում ենքd - 1-ով։ Այսպիսով՝ 8-ը դառնում է 7, 4-ը՝ 3, և այսպես շարունակ։ - Երբ թվանշանը 0 է, գրում ենք 9 և ռեկուրսիվ կերպով թվի մնացած մասից հանում ենք 1։ Օրինակ՝ 80-ի համար կստանայինք “08” (հիշեք, որ արգումենտն այստեղ շրջված է), որը դառնում է
9${InternalMinusOne<8>}, ապա “97,” և շրջելուց հետո՝ “79.”։
Այս տիպի մեջ մի գեղեցիկ հնարք է d-ի d - 1-ով փոխարինման եղանակը՝ մենք օգտագործում ենք [9, 0, 1, 2, 3, 4, 5, 6, 7, 8] tuple-ը և դրա մեջ ինդեքսավորում ենք Digit-ով։ Քանի որ tuple-ի տարրերը տեղաշարժված են, 3 ինդեքսում գտնվում է 2-ը, 8 ինդեքսում՝ 7-ը, և այլն։
Պարզ MinusOne
Վերոնշյալ տիպերը միավորենք մեկ տիպի մեջ, որը թվից հանում է մեկ և վերադարձնում թիվ՝
type AlmostFullMinusOne<T extends number> = ParseInt<
RemoveLeadingZeros<ReverseString<InternalMinusOne<ReverseString<`${T}`>>>>
>;
AlmostFullMinusOne<42>; // 41
Նման տիպեր կարդալիս սկսեք ամենաներքին մասից (այստեղ՝ ${T}) և շարժվեք դեպի դուրս։ Հետևելը հեշտացնելու համար ենթադրենք, որ նաև հաշվարկում ենք MinusOne<100>։
- Սկզբում
${T}-ն T-ն թվից դարձնում է string, այնպես որ100-ը դառնում է"100"։ - Հաջորդը՝ շրջում ենք այն, ուստի
"100"-ը դառնում է"001"։ - Դրանից հետո կիրառում ենք
InternalMinusOne։ Վերը նկարագրված կանոններին հետևելով՝ արդյունքը"990"է։ - String-ը նորից շրջում ենք, ուստի
"990"-ը դառնում է"099"։ - Հանում ենք ցանկացած առաջատար զրո, որ կարող էր հայտնվել ճանապարհին։ Սա անհրաժեշտ է, քանի որ հակառակ դեպքում մեր
ParseIntտիպը կվերադարձներ ընդհանուրnumber։ Մեր դեպքում"099"-ը դառնում է"99"։ - Վերջում կիրառում ենք
ParseInt, այնպես որ"99"-ը դառնում է99։
Ամբողջական MinusOne
Նախորդ բաժնի AlmostFullMinusOne տիպը չի ընդգրկում երկու կարևոր դեպք՝
- երբ
T-ն 0 է - երբ
T-ն < 0 է։
Առաջինը պարզ է՝ մենք պարզապես կոշտ կոդավորում ենք արդյունքը՝ T extends 0 ? -1 : ...։ Եթե թիվը բացասական է (նրա string ձևը սկսվում է “-” նշանով), վերցնում ենք նրա բացարձակ արժեքը, դրան ավելացնում ենք մեկ և վերականգնում ենք մինուս նշանը։ Թվին մեկ ավելացնելու համար պետք է InternalPlusOne, բայց քանի որ այն արտացոլում է InternalMinusOne-ը, ես այդքան մանրամասն չեմ անդրադառնա՝
type InternalPlusOne<S extends string> = S extends "9"
? "01"
: S extends `${infer Digit extends number}${infer Rest}`
? Digit extends 9
? `0${InternalPlusOne<Rest>}`
: `${[1, 2, 3, 4, 5, 6, 7, 8, 9][Digit]}${Rest}`
: never;
Սրանով վերջապես կարող ենք իրականացնել ամբողջական MinusOne-ը և համապատասխան PlusOne-ը՝
export type MinusOne<T extends number> = T extends 0
? -1 // T = 0
: `${T}` extends `-${infer Abs}`
? ParseInt<PutSign<ReverseString<InternalPlusOne<ReverseString<Abs>>>>> // T < 0
// T > 0
: ParseInt<
RemoveLeadingZeros<ReverseString<InternalMinusOne<ReverseString<`${T}`>>>>
>;
Եթե ուզում եք մարտահրավեր (նոր բան սովորելու լավագույն ճանապարհը), փորձեք իրականացնել PlusOne տիպը, որն արտացոլում է MinusOne տիպը։
Հակառակ դեպքում ահա իմ լուծումը՝
export type PlusOne<T extends number> = T extends -1
? 0
: `${T}` extends `-${infer Abs}`
? ParseInt<
PutSign<
RemoveLeadingZeros<ReverseString<InternalMinusOne<ReverseString<Abs>>>>
>
>
: ParseInt<
RemoveLeadingZeros<ReverseString<InternalPlusOne<ReverseString<`${T}`>>>>
>;
Ամփոփում
Սա բավական շատ տիպային մոգություն էր, և սա միայն սկիզբն է։
Հաջորդ գրառման մեջ ես ցույց կտամ, թե ինչպես է այս մոտեցումը թույլ տալիս աշխատել թվերի հետ TypeScript-ում և կառուցել էլ ավելի առաջադեմ Add և Subtract տիպեր։