typescript cheatsheet

Complex typescript type implement

// Tuple
type Tuple = [number, string];

// Object
interface IPerson {
  name: string;
  age: number;
}

class Person implements IPerson {
  name: string;
  age: number;
}

const person: IPerson = {
  name: "Jay",
  age: 43,
};

// Function
interface SayHello {
  (name: string): string;
}

const func: SayHello = (name: string) => {
  return "hello," + name;
};

// Constructor
interface PersonConstructor {
  new (name: string, age: number): IPerson;
}

function createPerson(ctor: PersonConstructor): IPerson {
  return new ctor("Jay", 43);
}

// enum
enum Color {
  RED = "red",
  YELLOW = "Yellow",
  BLUE = "blue",
}

const color = Color.RED;

// void
type v = void;

// never
type nv = never;
type nv_and_str1 = never & "123";
type nv_and_str2 = `${never}${"123"}`;
type nv_and_num1 = never & 321;
type nv_and_num2 = `${never}${1}`;

// any
type a = any;

// unknown
type uk = unknown;

// Decorate
interface IAnimal {
  name: string;
  weight?: number; //optional
}

// Condition
type res = 1 extends 2 ? true : false;

type isTwo<T> = T extends 2 ? true : false;

type one = isTwo<1>;

type two = isTwo<2>;

// String
// add
type first_name = "Jay";
type last_name = "Chou";
type the_man = `${first_name} ${last_name}`;

// Infer
// get part of str
type name = "Jay,Chou";
type surname = name extends `Jay,${infer rest}` ? rest : never;
type jay = name extends `${infer x},${infer y}` ? x : never;

// like regex but more flexible
// match the exact shape
// get first element of array
type First<Tuple extends unknown[]> = Tuple extends [infer T, ...infer R]
  ? T
  : never;

type getFirst = First<[1, 2, 3]>; // type getFirst = 1
type getFirst2 = First<[]>; // type getFirst2 = never

type Second<Tuple extends unknown[]> = Tuple extends [any, infer T, ...infer R]
  ? T
  : never;

type getSec = Second<[1, 2, 3]>; // type getSec = 2

// get last element of array
type Last<Arr extends unknown[]> = Arr extends [...any, infer T] ? T : never;
// output: type getLast = 3
type getLast = Last<[1, 2, 3]>;

// get rest element of array
type Rest<Arr extends unknown[]> = Arr extends [...infer R, unknown]
  ? R
  : never;

// output: type getRest = [1, 2]
type getRest = Rest<[1, 2, 3]>;

type Rest2<Arr extends unknown[]> = Arr extends [unknown, ...infer R]
  ? R
  : never;

// output: type getRest = [2, 3]
type getRest2 = Rest2<[1, 2, 3]>;

// array
type arr = unknown[];

// or
type a_or_b = 1 | 2;

// merge same type
type ObjType = { a: number } & { b: boolean };

type o = { a: number; b: boolean } extends ObjType ? true : false; // type o = true

// invaild->never
type ee = "str" & 100; // type ee = never

// object
type person = {
  name: "jay";
  age: 43;
};
type values = person[keyof person]; // type values = "jay" | 43

type person2 = {
  [key in keyof person]: person[key];
};

type MapType<T> = {
  [Key in keyof T]?: [T[Key], T[Key], "new CD!"];
};

type mt = MapType<{ name: "jay"; age: 43 }>;

type MapType2<T> = {
  [Key in keyof T as `${Key & string}${Key & string}`]: [
    T[Key],
    T[Key],
    T[Key]
  ];
};
type mt2 = MapType2<{ name: "jay"; age: 43 }>;

// StartsWith
type StartsWith<
  Str extends string,
  Perfix extends string
> = Str extends `${Perfix}${string}` ? true : false;

// output: type sw = true
type sw = StartsWith<"Jay Chou", "Jay">;

// output: type sw2 = false
type sw2 = StartsWith<"Jay Chou", "Lin">;

// Replace string
type Replace<
  Str extends string,
  From extends string,
  To extends string
> = Str extends `${infer P}${From}${infer S}` ? `${P}${To}${S}` : Str;

// output: type rp = "Jay Zhou"
type rp = Replace<"Jay Shou", "S", "Z">;
type rp2 = Replace<"Jay Shou", "X", "S">;

// Trim
// Trim right
// use recursive
type TrimRight<Str extends string> = Str extends `${infer Rest}${
  | " "
  | "\n"
  | "\t"}`
  ? TrimRight<Rest>
  : Str;

type tr = TrimRight<"Jay Zhou   ">;

// trim left
type TrimLeft<Str extends string> = Str extends `${
  | " "
  | "\n"
  | "\t"}${infer Rest}`
  ? TrimLeft<Rest>
  : Str;

type tl = TrimLeft<"  Jay Zhou">;

// trim = TrimRight&TrimLeft
// output: type tm = "Jay Zhou"
type tm = TrimRight<
  TrimLeft<`
  Jay Zhou

  `>
>;

// function
// get args of fucntion
function createCD(name: string, price: number) {
  return { name, price, author: "Jay Chou" };
}

// match: (x)=>y
type GetArgsOfFunc<Func extends Function> = Func extends (
  ...args: infer Args
) => unknown
  ? Args
  : never;

// type gaf = [name: string, price: number]
type gaf = GetArgsOfFunc<typeof createCD>;

type GetArgsOfFunc2<Func extends Function> = Func extends (
  aa: infer A,
  bb: infer B
) => unknown
  ? [A, B]
  : never;

// type gaf2 = [string, number]
type gaf2 = GetArgsOfFunc2<typeof createCD>;

// get return of function
type GetReturnOfFunc<Func extends Function> = Func extends (
  ...args
) => infer Return
  ? Return
  : never;

// type grf = { name: string; price: number; author: string; }
type grf = GetReturnOfFunc<typeof createCD>;

// type grf2 = "J"
type grf2 = GetReturnOfFunc<() => "J">;

// array
type Push<Arr extends unknown[], Ele> = [...Arr, Ele];

// output: type pushRes = [1, 2, 3, 4]
type pushRes = Push<[1, 2, 3], 4>;

// Unshift
type Unshift<Arr extends unknown[], Ele> = [Ele, ...Arr];

// output: type unshiftRes = [4, 1, 2, 3]
type unshiftRes = Unshift<[1, 2, 3], 4>;

// Zip
// type tuple1 = [1,2];
// type tuple2 = ['Jay Chou', 'Lin Junjie'];
// type tuple = [[1, 'Jay Chou'], [2, 'Lin Junjie']];

// fixed parameter
type Zip<
  Arr1 extends [unknown, unknown],
  Arr2 extends [unknown, unknown]
> = Arr1 extends [infer v1_1, infer v1_2]
  ? Arr2 extends [infer v2_1, infer v2_2]
    ? [[v1_1, v2_1], [v1_2, v2_2]]
    : []
  : [];

// type zipRes = [[1, "Jay Chou"], [2, "Lin Junjie"]]
type zipRes = Zip<[1, 2], ["Jay Chou", "Lin Junjie"]>;

// adaptive parameter
type Zip2<Arr1 extends unknown[], Arr2 extends unknown[]> = Arr1 extends [
  infer v1_1,
  ...infer Rest1
]
  ? Arr2 extends [infer v2_1, ...infer Rest2]
    ? [[v1_1, v2_1], ...Zip2<Rest1, Rest2>]
    : []
  : [];

// type zip2Res = [[1, "Jay Chou"], [2, "Lin Junjie"], [3, "Mikael J"]]
type zip2Res = Zip2<[1, 2, 3], ["Jay Chou", "Lin Junjie", "Mikael J"]>;

// CapitializeStr
type CapitializeStr<Str extends string> =
  Str extends `${infer First}${infer Rest}`
    ? `${Uppercase<First>}${Rest}`
    : Str;

// output: type capitializeStrRes = "Jay"
type capitializeStrRes = CapitializeStr<"jay">;

// hi_jay_chou ==> HiJayChou
type CamelCase<Str extends string> = Str extends `${infer first}_${infer rest}`
  ? `${CapitializeStr<first>}${CamelCase<rest>}`
  : CapitializeStr<Str>;

// type camelCaseRes = "HiJayChou"
type camelCaseRes = CamelCase<"hi_jay_chou">;

// hi_jay_chou ==> hiJayChou
// hi_j  ay_c hou
type CamelCase2<Str extends string> =
  Str extends `${infer first}_${infer right}${infer rest}`
    ? `${first}${Uppercase<right>}${CamelCase2<rest>}`
    : Str;

// type camelCaseRes2 = "hiJayChou"
type camelCaseRes2 = CamelCase2<"hi_jay_chou">;

// append arg to function
type AppendArgument<Func extends Function, Arg> = Func extends (
  ...args: infer Args
) => infer ReturnType
  ? (...args: [...Args, Arg]) => ReturnType
  : never;

// type appendArgumentRes = (args_0: string, args_1: number) => void
type appendArgumentRes = AppendArgument<(name: string) => void, number>;

// as
type UppercaseKey<Obj extends object> = {
  [Key in keyof Obj as Uppercase<Key & string>]: Obj[Key];
};

// type cd = { NAME: string; PRICE: number; }
type cd = UppercaseKey<{ name: string; price: number }>;

// Record<string, any>   ==> object

// toReadonly: add readonly
type ToReadonly<T extends Record<string, any>> = {
  readonly [key in keyof T]: T[key];
};

// type toReadonlyRes = { readonly name: "chopin"; readonly price: 99; }
type toReadonlyRes = ToReadonly<{ name: "chopin"; price: 99 }>;

// ToPartial
type ToPartial<T> = {
  [key in keyof T]?: T[key];
};

// type toReadonlyToPartialRes = { name?: "chopin"; price?: 99; }
type toReadonlyToPartialRes = ToPartial<{ name: "chopin"; price: 99 }>;

// toMutable: remove readonly
type ToMutable<T> = {
  -readonly [key in keyof T]: T[key];
};

// type toMutableRes = { name: "chopin"; price: 99; }
type toMutableRes = ToMutable<{ readonly name: "chopin"; readonly price: 99 }>;

// ToRequired
type ToRequired<T> = {
  [key in keyof T]-?: T[key];
};
// type toRequiredRes = { name: "chopin"; price: 99; }
type toRequiredRes = ToRequired<{ name?: "chopin"; price?: 99 }>;

// filter props by value type
type Filter<Obj extends Record<string, any>, ValueType> = {
  [key in keyof Obj as ValueType extends Obj[key] ? key : never]: Obj[key];
};

interface CD {
  name: string;
  price: number;
  artists: string[];
}
// type FilterRes = { name: string; price: number; }
type FilterRes = Filter<CD, string | number>;

// IsEqual
type IsEqual<A, B> = (A extends B ? true : false) &
  (B extends A ? true : false);
type isEqualRes = IsEqual<1, 1>;
type isEqualRes2 = IsEqual<{ name: "jay" }, { name: "jay" }>;

// IsInclude
type IsInclude<Arr extends unknown[], Item> = Arr extends [
  infer First,
  ...infer Rest
]
  ? IsEqual<First, Item> extends true
    ? true
    : IsInclude<Rest, Item>
  : false;

//type isIncludeRes = true
type isIncludeRes = IsInclude<[1, 2, 3], 1>;

//type isIncludeRes = false
type isIncludeRes2 = IsInclude<[1, 2, 3], 4>;

// RemoveItem
type RemoveItem<
  Arr extends unknown[],
  Item,
  Res extends unknown[] = []
> = Arr extends [infer First, ...infer Rest]
  ? IsEqual<First, Item> extends true
    ? RemoveItem<Rest, Item, Res>
    : RemoveItem<Rest, Item, [...Res, First]>
  : Res;

// type removeItemRes = [2, 3]
type removeItemRes = RemoveItem<[1, 2, 1, 3, 1], 1>;

//type removeItemRes2 = [1, 2, 3]
type removeItemRes2 = RemoveItem<[1, 2, 3], 4>;

// Replace All
// from begin to end
type ReplaceAll<
  Str extends string,
  From extends string,
  To extends string
> = Str extends `${infer First}${infer Rest}`
  ? IsEqual<First, From> extends true
    ? `${To}${ReplaceAll<Rest, From, To>}`
    : `${First}${ReplaceAll<Rest, From, To>}`
  : Str;

// pattern match
type ReplaceAll2<
  Str extends string,
  From extends string,
  To extends string
> = Str extends `${infer Left}${From}${infer Rest}`
  ? `${Left}${To}${ReplaceAll<Rest, From, To>}`
  : Str;

// type replaceAllRes = "Jay"
type replaceAllRes = ReplaceAll<"1J1a1y", "1", "">;
type replaceAllRes2 = ReplaceAll2<"1J1a1y", "1", "">;

// string union
type StrUnion<Str extends string> = Str extends `${infer First}${infer Rest}`
  ? First | StrUnion<Rest>
  : never;

// type strUnionRes = "J" | "a" | "y"
type strUnionRes = StrUnion<"Jay">;

// ReverseStr
type ReverseStr<Str extends string> = Str extends `${infer First}${infer Rest}`
  ? `${ReverseStr<Rest>}${First}`
  : Str;

// type reverseStrRes = "Jay"
type reverseStrRes = ReverseStr<"yaJ">;

// deep readonly
type DeepReadonly<Obj extends Record<string, any>> = {
  readonly [Key in keyof Obj]: Obj[Key] extends object
    ? DeepReadonly<Obj[Key]>
    : Obj[Key];
};

const deepObj = { a: { b: { c: "1", d: "2" } } };

type DeepReadonlyRes = DeepReadonly<typeof deepObj>;
type DeepReadonlyResA = DeepReadonly<typeof deepObj>["a"];
type DeepReadonlyResAB = DeepReadonly<typeof deepObj>["a"]["b"];

// Math
type NumTwo = [any, any]["length"];

// ADD in ts is like arr1.length + arr2.length
type BuildArr<
  Len extends number,
  Arr extends unknown[] = []
> = Arr["length"] extends Len ? Arr : BuildArr<Len, [...Arr, unknown]>;

// type Len2Array = [unknown, unknown]
type Len2Array = BuildArr<2>;

type Add<Num1 extends number, Num2 extends number> = [
  ...BuildArr<Num1>,
  ...BuildArr<Num2>
]["length"];

// type add1And2 = 3
type add1And2 = Add<1, 2>;

// Sub
type Sub<Num1 extends number, Num2 extends number> = BuildArr<Num1> extends [
  ...BuildArr<Num2>,
  ...infer Rest
]
  ? Rest["length"]
  : never;

// type subOneTwo = 3
type subOneTwo = Sub<4, 1>;

type Subtract<
  Num1 extends number,
  Num2 extends number
> = BuildArr<Num1> extends [...arr1: BuildArr<Num2>, ...arr2: infer Rest]
  ? Rest["length"]
  : never;

// type subOneTwo2 = 1
type subOneTwo2 = Subtract<2, 1>;