Master Advanced TypeScript: From Basic Types to Powerful Type Tricks

The author, a former Ant Group frontend engineer, shares notes collected while relearning TypeScript, covering both foundational concepts and high‑level type programming techniques.

Basic Types and Common Pitfalls

It explains the difference between any and unknown, the use of never in union filtering, and how keyof only extracts public property keys.

Advanced Conditional Types and Inference

Using infer inside conditional types, the article shows how to extract return types, parameter types, and how distributive conditional types work with unions. Example:

type ExtractFun<T> = {
  [K in keyof T]: T[K] extends Function ? K : never
}[keyof T];

Mapped Types and Key Remapping

It demonstrates key remapping with as to filter index signatures and transform object shapes, e.g., removing index signatures:

type RemoveIndexSignature<T> = {
  [Key in keyof T as TypeLiteralOnly<Key>]: T[Key]
};

Type‑Level Algorithms

Several type‑level algorithms are presented, such as converting a union to an intersection, generating permutations, parsing strings, and performing arithmetic at the type level. A notable example is the MinusOne challenge, solved by representing numbers as tuples of arrays and recursively adjusting digits:

type MinusOne<T extends number> =
  T extends 0 ? -1 :
  ToNumber<ArrToString<MinusArr<NumberToArr<T>>>>;

Practical Utility Types

Utility types like FlattenDepth, Repeat, and BinaryToDecimal illustrate how to count, repeat, and convert binary strings using tuple lengths.

Real‑World Type Challenges

The article solves several type‑challenge problems, including:

Transforming async and sync methods to a unified signature ( ConnectedFn).

Generating all string combinations from a set of characters ( AllCombinations).

Implementing FizzBuzz at the type level with efficient recursion.

Each solution showcases how TypeScript’s type system can express complex logic without runtime code.

Conclusion

While TypeScript’s type system was not originally designed for heavy computation, the guide demonstrates that with creative use of conditional types, tuple manipulation, and inference, developers can achieve powerful compile‑time checks and even solve algorithmic problems, reinforcing the importance of strong typing in modern frontend development.