TS Type Challenges · Part 9 — Hard Utility Types

type RequiredKeys<T> = {
  [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
}[keyof T];

Từng dòng

type RequiredKeys<T> = {
  [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
//▲ 1           ▲ 2   ▲ 3                              ▲ 4
}[keyof T];
//▲ 5

1. duyệt mọi key của T.
2. gỡ optional khỏi K khi map, nên b?: number được thử như { b: number } chứ không phải { b?: number }.
3. object một thuộc tính, ví dụ Pick<{a: string; b?: number}, 'b'> → { b?: number }.
4. nếu object rỗng thỏa type một key thì key đó optional → loại (never); không thì giữ K.
5. union các K được giữ: 'a' | never | 'c' → 'a' | 'c'.

Đánh giá type từng bước

Input: T = { a: string; b?: number; c: boolean }

// step 1: expand the mapped type (one entry per key)
type Mapped = {
  a: {} extends Pick<T, 'a'> ? never : 'a';
  b: {} extends Pick<T, 'b'> ? never : 'b';
  c: {} extends Pick<T, 'c'> ? never : 'c';
};

// step 2: evaluate Pick for each key
// Pick<T, 'a'> = { a: string }
// Pick<T, 'b'> = { b?: number }   ← optional marker present
// Pick<T, 'c'> = { c: boolean }

// step 3: evaluate {} extends ... for each
// {} extends { a: string }   → false  (must supply 'a')
// {} extends { b?: number }  → true   (may omit 'b')
// {} extends { c: boolean }  → false  (must supply 'c')

// step 4: resolve conditionals
type MappedResult = {
  a: 'a';      // false branch → keep K
  b: never;    // true branch  → drop
  c: 'c';      // false branch → keep K
};

// step 5: index by keyof T
type Result = MappedResult[keyof T];
// 'a' | never | 'c'  →  'a' | 'c'  ✓

Cạm bẫy

• Đừng bỏ -? — không có nó, {} extends { b?: number } có thể khác {} extends { b: number } tùy strictness; -? chuẩn hóa phép thử.
• {} extends Pick<T, K> phát hiện optional, không phải “có thể undefined” — { a: string | undefined } với a bắt buộc vẫn fail {} extends, nên a được giữ.
• Kết quả là union literal string, không phải object — dùng đổi key (as) khi cần object (xem GetRequired bên dưới).

Tóm tắt: key optional là những key mà {} thỏa Pick<T, K>; đảo phép thử đó và gom phần sống bằng [keyof T].

Cái hay — tính optional phát hiện được qua {} extends Pick<...> — là một trong các mẹo tái dùng nhiều nhất khi gõ type nâng cao.

type OptionalKeys<T> = {
  [K in keyof T]-?: {} extends Pick<T, K> ? K : never;
}[keyof T];

Từng dòng

Chỉ dòng 4 khác RequiredKeys:

{} extends Pick<T, K> ? K : never;
// true  → keep K  (optional)
// false → never   (required)

Đánh giá type từng bước

Input: T = { a: string; b?: number; c?: boolean }

// step 1: Pick each key
// Pick<T, 'a'> = { a: string }
// Pick<T, 'b'> = { b?: number }
// Pick<T, 'c'> = { c?: boolean }

// step 2: {} extends Pick<T, K>?
// 'a' → false
// 'b' → true
// 'c' → true

// step 3: map results
type Mapped = { a: never; b: 'b'; c: 'c' };

// step 4: [keyof T]
type Result = Mapped[keyof T];
// never | 'b' | 'c'  →  'b' | 'c'  ✓

Cạm bẫy

• Chỉ đảo nhánh, còn lại giống hệt — lỗi copy-paste hay gặp; kiểm tra lại ? K : never vs ? never : K.
• Key có ?: undefined vẫn là optional — {} gán được, nên có trong OptionalKeys.
• Đừng nhầm với “value có thể undefined” — { a: string | undefined } với a bắt buộc thuộc RequiredKeys, không phải đây.

Tóm tắt: giữ K khi {} extends Pick<T, K> là true — đúng ca optional.

Giống RequiredKeys nhưng đổi nhánh: giữ K khi {} extends Pick<T, K> là true (ca optional). Một khi đã nhận ra phép thử optional, cả hai đều bật ra từ cùng khuôn.

type GetRequired<T> = {
  [K in keyof T as T[K] extends Required<T>[K] ? K : never]: T[K];
};

Từng dòng

type GetRequired<T> = {
  [K in keyof T as T[K] extends Required<T>[K] ? K : never]: T[K];
//               ▲ 1   ▲ 2                              ▲ 3      ▲ 4
};

1. mapped type có đổi key; key đầu ra từ biểu thức as, không trực tiếp từ K.
2. với optional b?: number, đây là number (không undefined); với bắt buộc a: string, vẫn là string.
3. string extends string → true (bắt buộc); number | undefined extends number → false (optional mang undefined).
4. type value lấy từ T gốc, không từ Required<T>.

Đánh giá type từng bước

Input: T = { a: string; b?: number }

// step 1: compute Required<T>
type Req = Required<T>;
// { a: string; b: number }  — 'b' lost its optionality

// step 2: for each K, compare T[K] vs Required<T>[K]
// K = 'a': T['a'] = string,        Required<T>['a'] = string
//          string extends string  → true  → keep key 'a'
// K = 'b': T['b'] = number | undefined,  Required<T>['b'] = number
//          number | undefined extends number  → false  → remap to never (drop)

// step 3: build output object (never keys omitted)
type Result = { a: string };
// ✓

Cạm bẫy

• [keyof T] vs as — [keyof T] ra union; as ra object. Chọn công cụ theo hình dạng cần.
• GetOptional đảo phép thử — T[K] extends Required<T>[K] ? never : K chỉ giữ key optional.
• Key bắt buộc có \| undefined trong value — a: string | undefined (bắt buộc) fail extends so với string, nên bị loại; khớp phân biệt của TS giữa optional key và undefined trong value.

Tóm tắt: đổi mỗi key thành K hoặc never dựa trên T[K] đã khớp dạng bắt buộc chưa; key optional mang undefined và fail.

So với RequiredKeys: cái đó trả key; cái này trả object dựng từ các key đó. (GetOptional y vậy nhưng lật phép thử.)

type Chainable<T = {}> = {
  option<K extends string, V>(
    key: K extends keyof T ? never : K,
    value: V,
  ): Chainable<Omit<T, K> & Record<K, V>>;
  get(): T;
};

Từng dòng

type Chainable<T = {}> = {
//            ▲ 1
  option<K extends string, V>(
  //     ▲ 2              ▲ 3
    key: K extends keyof T ? never : K,
    //   ▲ 4
    value: V,
  ): Chainable<Omit<T, K> & Record<K, V>>;
  //          ▲ 5
  get(): T;
  //     ▲ 6
};

1. các option đã tích luỹ; bắt đầu rỗng.
2. key phải là string; K được suy ra là literal string ('foo', không phải string).
3. type value suy ra từ đối số thứ hai (123 → number).
4. nếu K đã là key của T, type tham số là never → không truyền được giá trị nào → lỗi biên dịch.
5. gỡ K cũ (nếu có), rồi thêm { [K]: V }; giao gộp thành object phẳng.
6. trả type đã tích luỹ đầy đủ.

Đánh giá type từng bước

declare const config: Chainable;
// step 0: T = {}

config.option('foo', 123);
// step 1: K = 'foo', V = number
//         'foo' extends keyof {} ? never : 'foo'  →  'foo'  (ok)
//         new T = Omit<{}, 'foo'> & Record<'foo', number> = { foo: number }
//         return type: Chainable<{ foo: number }>

config.option('name', 'type-challenges');
// step 2: T = { foo: number }
//         K = 'name', V = string
//         'name' extends 'foo' ? never : 'name'  →  'name'  (ok)
//         new T = { foo: number; name: string }

config.option('bar', { value: 'Hello World' });
// step 3: T = { foo: number; name: string }
//         K = 'bar', V = { value: string }
//         new T = { foo: number; name: string; bar: { value: string } }

config.get();
// step 4: returns T = { foo: number; name: string; bar: { value: string } }  ✓

// step 5 (error demo): on Chainable<{ foo: number }>
// .option('foo', 'again')
// 'foo' extends 'foo' ? never : 'foo'  →  never
// Argument of type '"again"' is not assignable to parameter of type 'never'  ✗

Cạm bẫy

• never trên tham số, không phải return type — trả never từ option() sẽ gãy chain; làm key thành never chỉ chặn lời gọi sai.
• Omit<T, K> & Record<K, V> vs T & Record<K, V> — giao trên key trùng ra T[K] & V (thường never), không thay sạch; Omit trước tránh điều đó.
• Suy ra literal cần đối số cụ thể — option(someString, v) nới K thành string và mất độ chính xác chặn key trùng.
• Mặc định T = {} — không có thì người gọi phải tự cung cấp type ban đầu.

Tóm tắt: mang option tích luỹ trong T, suy ra literal K/V mỗi lần, chặn key trùng bằng never, gộp bằng Omit & Record.

Đây là ví dụ kinh điển của mang trạng thái trong tham số type qua các lời gọi method — cũng là kỹ thuật sau query builder, thư viện form, và ORM.

type GetOptional<T> = {
  [K in keyof T as T[K] extends Required<T>[K] ? never : K]: T[K];
};

Cùng hình dạng GetRequired, đổi nhánh — giữ key khi thuộc tính có khác dạng bắt buộc (tức vẫn mang undefined từ optional).

// step 1: T = { a: string; b?: number }
// 'a': string extends string → true  → never (drop)
// 'b': number | undefined extends number → false → keep 'b'
// Result: { b?: number }  ✓

Đề cấm thêm lại key đã có. Với chỉ key: K, .option('foo', …) trùng vẫn qua type-check và sinh foo: OldType & NewType qua giao — thường là never, nhưng âm thầm. Map tham số key trùng về never khiến .option() sai không gọi được — TypeScript báo “not assignable to never” ngay chỗ gọi.