1
2
3
4

function fmt(v: Date | string) {
  if (v instanceof Date) return v.toISOString();   // v: Date
  return v.toUpperCase();                          // v: string
}

1
2
3
4
5
6
7

type A = { a: number };
type B = { b: string };

function f(v: A | B) {
  if ("a" in v) return v.a;   // v: A
  return v.b;                 // v: B
}

1
2
3
4
5
6
7
8

type P = { a?: number; b?: string };

function g(p: P) {
  if ("a" in p) {
    return p.a;    // 类型是 number | undefined ⚠️ 因为 a 本身可选
  }
  return p.b;
}

1
2
3
4

function f(v: string | null | undefined) {
  if (v) return v.length;   // 排除了 null / undefined / ""
  return 0;
}

1
2
3
4
5
6

function f(a: string | number, b: string | boolean) {
  if (a === b) {
    return a.toUpperCase();   // a 和 b 都收窄为 string（唯一的公共成员）
  }
  return "";
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

type Shape =
  | { kind: "circle"; r: number }
  | { kind: "square"; s: number }
  | { kind: "rect"; w: number; h: number };

function area(sh: Shape): number {
  switch (sh.kind) {
    case "circle": return Math.PI * sh.r ** 2;
    case "square": return sh.s ** 2;
    case "rect":   return sh.w * sh.h;
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

function area2(sh: Shape): number {
  switch (sh.kind) {
    case "circle": return Math.PI * sh.r ** 2;
    case "square": return sh.s ** 2;
    case "rect":   return sh.w * sh.h;
    default:
      const _exhaustive: never = sh;   // ✅ 所有分支覆盖后，sh 是 never
      return _exhaustive;
  }
}

// 新增成员后立刻报错：
// ❌ TS2322: Type '{ kind: "triangle"; ... }' is not assignable to type 'never'.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

function isString(v: unknown): v is string {
  return typeof v === "string";
}

function f(v: unknown) {
  if (isString(v)) {
    return v.toUpperCase();   // ✅ v 收窄为 string
  }
  return null;
}

1
2
3
4
5
6
7

// ✅ 箭头函数也可以
const isNumber = (v: unknown): v is number => typeof v === "number";

// ❌ 不能对属性写谓词——语法直接不通过
function bad(o: { a: unknown }): o.a is string { return typeof o.a === "string"; }
//                              ~~~~~~~~~~~~~~~~~ error TS1144: '{' or ';' expected.
//                                                   （谓词位置只接受标识符，不接受属性访问）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

type User = { id: number; name: string };

function isUser(v: unknown): v is User {
  return (
    typeof v === "object" && v !== null &&
    typeof (v as User).id === "number" &&
    typeof (v as User).name === "string"
  );
}

// 数组守卫
function isUserArray(v: unknown): v is User[] {
  return Array.isArray(v) && v.every(isUser);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

function assertIsString(v: unknown): asserts v is string {
  if (typeof v !== "string") {
    throw new Error("期望 string");
  }
}

function f(v: unknown) {
  assertIsString(v);
  return v.toUpperCase();   // ✅ 调用之后 v 就是 string
}

1
2
3
4
5
6
7
8
9

// 无条件的真值断言
function assert(v: unknown): asserts v {
  if (!v) throw new Error("断言失败");
}

function g(s: string | null) {
  assert(s);
  return s.toUpperCase();   // ✅ 去掉了 null
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

function assertDefined<T>(v: T | null | undefined): asserts v is T {
  if (v === null || v === undefined) {
    throw new Error("值不能为空");
  }
}

function h(v: string | undefined) {
  assertDefined(v);
  return v.toUpperCase();   // ✅ 去掉了 undefined
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

const arr = [1, "a", null, undefined, 2];

// 5.5 之前：结果是 (string | number | null | undefined)[]，null 没被去掉
// 5.5+：自动推断为 (x) => x is string | number
const filtered = arr.filter((x) => x !== null && x !== undefined);

const total = filtered.reduce<number>(
  (sum, x) => sum + (typeof x === "number" ? x : 0),
  0,
);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// ✅ 会被推断为 x is number
const a = arr.filter((x) => typeof x === "number");

// ❌ 有显式标注 -> 结果就是 boolean，不收窄
const b = arr.filter((x: unknown) => typeof x === "number");

// ❌ 多语句函数体 -> 不推断
const c = arr.filter((x) => {
  const ok = typeof x === "number";
  return ok;
});

// ✅ 想要收窄就手写谓词
const d = arr.filter((x): x is number => {
  const ok = typeof x === "number";
  return ok;
});

1
2
3
4
5

function f(v: string | null | undefined) {
  if (!v) return;
  v = maybeGet();          // ⚠️ 重新赋值，之前的收窄作废
  return v.toUpperCase();  // ❌ TS18048: 'v' is possibly 'undefined'.
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

type State = { value: string | null };

function bad(s: State) {
  if (s.value !== null) {
    mutate(s);                    // ⚠️ 编译器不知道这个函数做了什么
    return s.value.toUpperCase(); // ❌ TS18047: 's.value' is possibly 'null'.
  }
  return "";
}

function good(s: State) {
  const v = s.value;              // ✅ 先取出到局部 const
  if (v !== null) {
    mutate(s);
    return v.toUpperCase();       // ✅ v 不受 s 变化影响
  }
  return "";
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// 索引访问：每次 obj[key] 都是新求值
function f(obj: Record<string, string | null>, key: string) {
  if (obj[key] !== null) {
    return obj[key].toUpperCase();   // ❌ TS18047: 'obj[key]' is possibly 'null'.
  }
  return "";
}

function fixed(obj: Record<string, string | null>, key: string) {
  const v = obj[key];                // ✅ 一次求值，存起来
  if (v !== null) return v.toUpperCase();
  return "";
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 泛型参数不收窄
function g<T>(v: T | null) {
  if (v !== null) {
    return v;      // 类型是 T & {} —— 不是 T ⚠️
  }
  return null;
}

// 需要精确类型时改用泛型约束
function h<T>(v: T | null): T | null {
  return v ?? null;
}