Wonderful use of TS type gymnastics string

TS Type gymnastics And Wonderful use of string

Here is a record of some ingenious string processing skills encountered in the process of doing questions , The main topic introduced later is 00529-medium-absolute

For the use of strings , The chapter of pre knowledge has been introduced , Examples are as follows . After understanding this part of the examples, I believe that many problems can be solved

type testInfer<T extends string> = T extends `${
      infer F}${
      infer S}${
      infer R}` ? [F, S, R] : T

type testInfer1 = testInfer<'123456'>
//  According to the characteristics of placeholders , front F and S To occupy separately 2 Characters , Give the rest R Occupied 
// type testInfer1 = ["1", "2", "3456"]

//  Make a little change , stay S Add a... After the placeholder 5
type testInfer2<T extends string> = T extends `${
      infer F}${
      infer S}5${
      infer R}` ? [F, S, R] : T
type testInfer3 = testInfer<'123456'>
// F  Occupy the first character  = 1
// S  occupy 2-4, Because in R There was one before 5, therefore S Represents the beginning of the second character to 5 All characters of 
//  that R It's from 5 Start , To the end , So the results are as follows ：
// type testInfer1 = ["1", "234", "6"]

00529-medium-absolute Topic explanation

demand ： Implement a receive string,number or bigInt Of type parameter Absolute type , Returns a positive string .

• receive string,number, perhaps bigInt
• Returns a positive integer
• Return string

Pick a few representative test cases

type testcase = Absolute<0>
type testcase = Absolute<-5>
type testcase = Absolute<'0'>
type testcase = Absolute<'-0'>
type testcase = Absolute<'10'>
type testcase = Absolute<-1_000_000n>
type testcase = Absolute<9_999n>

Their thinking

Ideas 1： A more circuitous idea

• First convert numbers into strings
• Compare string by string （ Use infer Extract each string , Then compare , After the comparison is successful, it is stored in a variable R in ）
• When the incoming string is empty, the variable is returned R

Ideas 1 Realization ：

type NumberStr = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'

type Absolute<T extends number | string | bigint, R extends string = ''> = `${
      T}` extends `${
      infer F}${
      infer Rest}`
  ? F extends NumberStr
    ? Absolute<Rest, `${
      R}${
      F}`>
    : Absolute<Rest, R>
  : R

among , When the incoming generic T May be number perhaps bigInt When it comes to type , It can't be used directly extends xxx

So the first trick is ${T} Whether it is string type or not , All converted to strings （ This is also because numeric types can be converted to strings ）

The rest is to compare character by character .

---

Ideas 2： Use digital features , such as 1_000_000n In procedure tostring In fact, it will be automatically converted to 1000000, We don't need to consider too much removal \_ perhaps Remove n The logic of

Ideas 2 Realization ：

type Absolute<T extends number | string | bigint> = `${
      T}` extends `-${
      infer Num}` ? Num : `${
      T}`

This method directly matches whether the incoming content has - Number

• If not , Description is a positive integer （ It could be numbers ） So wrap a layer `` Output directly as a string
• Yes - No , utilize infer and Properties of strings , Rule out the first -, The rest is the string corresponding to the number

Summary

• In the process of matching , have access to ${T} The grammar of , hold number Also converted to string
• Numeric type , Include bigInt In fact, the type conversion will be automatically converted to numbers , Using this feature, you can write less code