Գնահատել նախագիծը
← Բոլոր հրապարակումները

Առաջադեմ տիպային մակարդակի թվաբանություն TypeScript-ում, մաս 1՝ իրականացումը

Տեսեք, թե ինչպես կառուցել `Add` և `Subtract` գործողություններ, որոնք գոյություն ունեն զուտ տիպերի մակարդակում և հաշվարկվում են կոմպիլյացիայի ժամանակ։

6 րոպե
Typescriptառաջադեմ TypeScriptտիպային մակարդակի ծրագրավորումթվաբանությունգումարում

Եթե կարդացել եք 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 ալգորիթմը հետևյալն է՝

  1. Արգումենտը դարձնել string

Երբ այն դրական է, մենք string-ների մշակման միջոցով կառուցում ենք string, որը ներկայացնում է մեկով նվազեցված թիվը

Երբ այն բացասական է, մենք հանում ենք մինուս նշանը, կառուցում ենք string, որը ներկայացնում է մեկով ավելացված թիվը, և նշանը վերադարձնում ենք

  1. Ստացված 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 տիպեր։