基础定义

type InputType = string | number | bigint | boolean | null | undefined;

字符串基本操作

StringAdd

type StringAdd<T extends InputType[] = []> = T extends [
  infer S extends InputType,
  ...infer Rest extends InputType[],
]
  ? `${S}${StringAdd<Rest>}`
  : ``;

StringLength

type StringLength<
  S extends InputType,
  Rest extends InputType[] = [],
> = `${S}` extends `${infer L}${infer R}`
  ? StringLength<R, [...Rest, L]>
  : Rest['length'];

StringToArray

type StringToArray<
  S extends InputType,
  Rest extends string[] = [],
> = `${S}` extends `${infer L}${infer R}`
  ? StringToArray<R, [...Rest, L]>
  : Rest;

StringToUniqueArray

type StringToUniqueArray<
  S extends InputType,
  Rest extends string[] = [],
  Temp extends string = never,
> = `${S}` extends `${infer L}${infer R}`
  ? L extends Temp
    ? StringToUniqueArray<R, Rest, Temp>
    : StringToUniqueArray<R, [...Rest, L], Temp | L>
  : Rest;

StringReverse

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

StringToKeySet

type StringToKeySet<
  S extends InputType,
  Rest extends InputType[] = [],
  Temp extends string = never,
> = `${S}` extends `${infer L}${infer R}`
  ? L extends Temp
    ? StringToKeySet<R, Rest, Temp>
    : StringToKeySet<R, [...Rest, L], Temp | L>
  : Temp;

StringCharCount

type StringCharCount<
  S extends InputType,
  F extends InputType = S,
  CountObject extends Record<StringToKeySet<F>, InputType[]> = {
    [key in StringToKeySet<F>]: [];
  },
> = `${S}` extends `${infer L}${infer R}`
  ? StringCharCount<
      R,
      F,
      {
        [key in StringToKeySet<F>]: L extends key
          ? [...CountObject[key], L]
          : CountObject[key];
      }
    >
  : {
      [key in StringToKeySet<F>]: CountObject[key]['length'];
    };

StringIsChar

type StringIsChar<S extends string> = 1 extends StringToArray<S>['length']
  ? true
  : false;

字符串替换

StringReplace

type StringReplace<
  S extends InputType,
  P extends InputType,
  T extends InputType,
> = `${S}` extends `${infer LeftRest}${P}${infer RightRest}`
  ? `${LeftRest}${T}${RightRest}`
  : `${S}`;

StringReplaceAll

type StringReplaceAll<
  S extends InputType,
  P extends InputType,
  T extends InputType,
> = `${S}` extends `${infer LeftRest}${P}${infer RightRest}`
  ? `${StringReplaceAll<LeftRest, P, T>}${T}${StringReplaceAll<
      RightRest,
      P,
      T
    >}`
  : `${S}`;

字符串trim相关

StringLeftTrim

type StringLeftTrim<S extends InputType> = `${S}` extends ` ${infer Rest}`
  ? `${StringLeftTrim<Rest>}`
  : S;

StringRightTrim

type StringRightTrim<S extends InputType> = `${S}` extends `${infer Rest} `
  ? `${StringRightTrim<Rest>}`
  : S;

StringTrim

type StringTrim<S extends InputType> = StringLeftTrim<StringRightTrim<S>>;

字符串查找相关

StringStartsWith

type StringStartsWith<
  T extends InputType,
  P extends InputType,
> = `${T}` extends `${P}${infer _}` ? T : never;

StringEndsWith

type StringEndsWith<
  T extends InputType,
  P extends InputType,
> = `${T}` extends `${infer _}${P}` ? T : never;

StringIncludes

type StringIncludes<
  T extends InputType,
  P extends InputType,
> = `${T}` extends `${infer _1}${P}${infer _2}` ? T : never;