字符串操作类型

字符串操作类型

TypeScript 提供了多种内置工具类型用于处理字符串类型。这些类型能够实现字符串的拼接、替换、大小写转换等操作，极大增强了类型系统的表现力。

模板字面量类型

模板字面量类型允许通过插值方式组合字符串类型：

type World = "world";
type Greeting = `hello ${World}`;  // "hello world"

type Vertical = "top" | "middle" | "bottom";
type Horizontal = "left" | "center" | "right";
type Position = `${Vertical}-${Horizontal}`;
// "top-left" | "top-center" | "top-right" | 
// "middle-left" | "middle-center" | "middle-right" | 
// "bottom-left" | "bottom-center" | "bottom-right"

大小写转换

Uppercase、Lowercase、Capitalize 和 Uncapitalize 是四种内置的字符串转换类型：

type UppercaseStr = Uppercase<"typescript">;  // "TYPESCRIPT"
type LowercaseStr = Lowercase<"TYPESCRIPT">;  // "typescript"
type Capitalized = Capitalize<"typescript">;  // "Typescript"
type Uncapitalized = Uncapitalize<"Typescript">;  // "typescript"

字符串拆分与组合

通过类型推断可以实现字符串拆分：

type Split<S extends string, D extends string> =
    S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] : [S];

type PathParts = Split<"src/components/Button.tsx", "/">;
// ["src", "components", "Button.tsx"]

组合字符串数组：

type Join<T extends string[], D extends string> =
    T extends [] ? "" :
    T extends [infer F] ? F :
    T extends [infer F, ...infer R] ? `${F & string}${D}${Join<R, D>}` : string;

type Path = Join<["src", "components", "Button.tsx"], "/">;
// "src/components/Button.tsx"

字符串替换

实现字符串替换操作：

type Replace<
    S extends string,
    From extends string,
    To extends string
> = From extends ""
    ? S
    : S extends `${infer Prefix}${From}${infer Suffix}`
    ? `${Prefix}${To}${Suffix}`
    : S;

type Replaced = Replace<"TypeScript is awesome", "awesome", "great">;
// "TypeScript is great"

字符串模式匹配

利用条件类型进行模式匹配：

type ExtractQueryParam<S extends string> =
    S extends `${string}?${infer Query}` ? Query : never;

type QueryString = ExtractQueryParam<"/user?id=123&name=foo">;
// "id=123&name=foo"

字符串长度计算

递归计算字符串长度：

type StringLength<S extends string> = 
    S extends `${infer First}${infer Rest}` 
    ? StringLength<Rest> extends infer Length 
      ? [First, ...(Length extends any[] ? Length : [])]
      : never
    : [];

type Length = StringLength<"hello">["length"];  // 5

字符串前缀/后缀检查

检查字符串是否以特定模式开头或结尾：

type StartsWith<S extends string, Prefix extends string> = 
    S extends `${Prefix}${string}` ? true : false;

type EndsWith<S extends string, Suffix extends string> = 
    S extends `${string}${Suffix}` ? true : false;

type HasPrefix = StartsWith<"TypeScript", "Type">;  // true
type HasSuffix = EndsWith<"TypeScript", "Script">;  // true

字符串截取

实现类似 JavaScript 的 slice 操作：

type Slice<
    S extends string,
    Start extends number,
    End extends number,
    Result extends string = "",
    Count extends any[] = []
> = Count["length"] extends End
    ? Result
    : Count["length"] extends Start
    ? Slice<S, Start, End, `${Result}${S[Start]}`, [...Count, any]>
    : Count["length"] extends number
    ? Slice<S, Start, End, Result, [...Count, any]>
    : never;

type Sliced = Slice<"TypeScript", 4, 10>;  // "Script"

字符串反转

递归实现字符串反转：

type ReverseString<S extends string> =
    S extends `${infer First}${infer Rest}`
    ? `${ReverseString<Rest>}${First}`
    : S;

type Reversed = ReverseString<"TypeScript">;  // "tpircSepyT"

字符串去空白

处理字符串两端的空白字符：

type TrimLeft<S extends string> =
    S extends ` ${infer Rest}` ? TrimLeft<Rest> : S;

type TrimRight<S extends string> =
    S extends `${infer Rest} ` ? TrimRight<Rest> : S;

type Trim<S extends string> = TrimLeft<TrimRight<S>>;

type Trimmed = Trim<"  TypeScript  ">;  // "TypeScript"

字符串包含检查

检查字符串是否包含子串：

type Includes<
    S extends string,
    Sub extends string
> = S extends `${string}${Sub}${string}` ? true : false;

type Contains = Includes<"TypeScript", "Script">;  // true

字符串重复

实现字符串重复操作：

type Repeat<
    S extends string,
    N extends number,
    Result extends string = "",
    Count extends any[] = []
> = Count["length"] extends N
    ? Result
    : Repeat<S, N, `${Result}${S}`, [...Count, any]>;

type Repeated = Repeat<"A", 5>;  // "AAAAA"

字符串填充

实现类似 padStart 和 padEnd 的功能：

type PadStart<
    S extends string,
    N extends number,
    Fill extends string = " ",
    Current extends string = S
> = Current extends infer Str 
    ? Str extends string
      ? StringLength<Str> extends N
        ? Str
        : PadStart<S, N, Fill, `${Fill}${Str}`>
      : never
    : never;

type Padded = PadStart<"42", 5, "0">;  // "00042"

字符串字符提取

获取字符串中的特定位置字符：

type CharAt<
    S extends string,
    N extends number,
    Count extends any[] = []
> = Count["length"] extends N
    ? S extends `${infer Char}${string}`
      ? Char
      : never
    : S extends `${string}${infer Rest}`
    ? CharAt<Rest, N, [...Count, any]>
    : never;

type Char = CharAt<"TypeScript", 4>;  // "S"

字符串编码转换

模拟字符串编码转换操作：

type EncodeURIComponent<S extends string> =
    S extends `${infer Head}${infer Tail}`
    ? Head extends " "
      ? `%20${EncodeURIComponent<Tail>}`
      : Head extends "!"
      ? `%21${EncodeURIComponent<Tail>}`
      // 其他字符处理...
      : `${Head}${EncodeURIComponent<Tail>}`
    : S;

type Encoded = EncodeURIComponent<"hello world!">;  // "hello%20world%21"

字符串比较

实现字符串的字典序比较：

type CompareStrings<
    A extends string,
    B extends string
> = A extends B
    ? 0
    : A extends `${infer AChar}${infer ARest}`
    ? B extends `${infer BChar}${infer BRest}`
      ? AChar extends BChar
        ? CompareStrings<ARest, BRest>
        : AChar extends string
        ? BChar extends string
          ? AChar extends Exclude<string, BChar>
            ? 1
            : -1
          : never
        : never
      : 1
    : B extends `${string}${string}`
    ? -1
    : 0;

type Comparison = CompareStrings<"apple", "banana">;  // -1 (apple < banana)