类型守卫与类型收窄

function len(x: string | number[]): number {
  if (typeof x === "string") return x.length;   // 这里 x 是 string
  return x.length;                               // 这里 x 是 number[]
}

function fmt(d: Date | string): string {
  return d instanceof Date ? d.toISOString() : d;
}

type Cat = { meow(): void };
type Dog = { bark(): void };
 
function speak(a: Cat | Dog): void {
  if ("meow" in a) a.meow();
  else a.bark();
}

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

type User = { kind: "user"; name: string; age: number };
 
function isUser(v: unknown): v is User {
  if (typeof v !== "object" || v === null) return false;
  const o = v as Record<string, unknown>;
  return o.kind === "user" && typeof o.name === "string" && typeof o.age === "number";
}
 
const raw: unknown = JSON.parse('{"kind":"user","name":"Ada","age":36}');
 
if (isUser(raw)) {
  // 这里 raw 被收窄成 User，可以放心访问属性
  console.log("合法用户:", raw.name, raw.age);
} else {
  console.log("数据非法");
}
 
const bad: unknown = JSON.parse('{"kind":"user","name":"Bob"}');
console.log("bad 是 User 吗:", isUser(bad));
 
// 谓词函数配合数组过滤，能把 (T | null)[] 变成 T[]
function isNotNull<T>(v: T | null | undefined): v is T {
  return v !== null && v !== undefined;
}
const mixed: (string | null)[] = ["a", null, "b", null];
const clean: string[] = mixed.filter(isNotNull);
console.log("过滤后:", JSON.stringify(clean), "长度", clean.length);

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

function shout(v: unknown): string {
  assertIsString(v);
  return v.toUpperCase();   // 这里 v 已经是 string
}

function assertIsNumber(v: unknown): asserts v is number {
  if (typeof v !== "number" || Number.isNaN(v)) {
    throw new TypeError("期望 number，实际是 " + typeof v);
  }
}
 
function invariant(cond: unknown, msg: string): asserts cond {
  if (!cond) throw new Error("不变量被破坏: " + msg);
}
 
function double(v: unknown): number {
  assertIsNumber(v);
  return v * 2;    // v 已收窄为 number
}
 
console.log("double(21) =", double(21));
 
try {
  double("21");
} catch (e) {
  console.log("捕获:", (e as Error).message);
}
 
function head<T>(arr: T[]): T {
  invariant(arr.length > 0, "数组不能为空");
  const first = arr[0];
  invariant(first !== undefined, "首元素存在");
  return first;
}
console.log("head:", head([10, 20, 30]));
 
try {
  head<number>([]);
} catch (e) {
  console.log("捕获:", (e as Error).message);
}

const a = "up";                      // 类型 string
const b = "up" as const;             // 类型 "up"
 
const arr1 = [1, 2, 3];              // number[]
const arr2 = [1, 2, 3] as const;     // readonly [1, 2, 3]
 
const cfg = { mode: "dark" } as const;  // { readonly mode: "dark" }

const MODES = ["idle", "running", "done"] as const;
type Mode = typeof MODES[number];   // "idle" | "running" | "done"
 
type Shape =
  | { kind: "circle"; r: number }
  | { kind: "rect"; w: number; h: number }
  | { kind: "square"; side: number };
 
function assertNever(x: never): never {
  throw new Error("未处理的分支: " + JSON.stringify(x));
}
 
function area(s: Shape): number {
  switch (s.kind) {
    case "circle":
      return Math.PI * s.r * s.r;
    case "rect":
      return s.w * s.h;
    case "square":
      return s.side * s.side;
    default:
      // 三个分支都处理了，这里 s 的类型是 never
      return assertNever(s);
  }
}
 
const shapes: Shape[] = [
  { kind: "circle", r: 1 },
  { kind: "rect", w: 2, h: 3 },
  { kind: "square", side: 4 },
];
for (const s of shapes) {
  console.log(s.kind, "面积 =", area(s).toFixed(2));
}
 
console.log("所有模式:", MODES.join(", "));
const m: Mode = "running";
console.log("当前模式:", m);
 
// 运行时也做一次穷尽保护：伪造一个非法值
const fake = { kind: "triangle", base: 1 } as unknown as Shape;
try {
  area(fake);
} catch (e) {
  console.log("捕获:", (e as Error).message);
}

const list: (string | null)[] = ["x", null];
// 不推荐：编译器不保证 list[0] 两次访问一致
// if (list[0] !== null) console.log(list[0].length);
 
const first = list[0];
if (first !== null && first !== undefined) console.log(first.length);