类型守卫与自定义守卫

// 保存时
localStorage.setItem('draft', JSON.stringify({
  title: '类型收窄笔记',
  wordCount: 1200,
  tags: ['typescript'],
}));

interface DocMeta {
  title: string;
  wordCount: number;
  tags: string[];
}

const raw = JSON.parse(localStorage.getItem('draft') ?? 'null');
const draft = raw as DocMeta;          // 编译器闭嘴了
console.log(draft.title.toUpperCase()); // 运行时炸了：raw 是 null

function format(value: string | number): string {
  if (typeof value === 'string') {
    return value.trim();        // 这个分支里 value 一定是 string
  }
  return value.toFixed(2);      // 排除 string 后，剩下的只有 number
}

function greet(name: string | null) {
  if (name) {
    return name.toUpperCase();  // null 被排除（注意空字符串也会被排除，见坑点）
  }
  return '无名氏';
}

function compare(a: string | number, b: string | number) {
  if (a === b) {
    // a === b 成立时，TS 推出两者类型相同：string | number
    return a + b;
  }
  return 0;
}

interface EpubDoc { format: 'epub'; chapters: number }
interface PdfDoc  { format: 'pdf';  pages: number }

function pageCount(doc: EpubDoc | PdfDoc): number {
  if ('chapters' in doc) {
    return doc.chapters;        // 有 chapters 属性的只可能是 EpubDoc
  }
  return doc.pages;
}

class PreviewError extends Error {
  constructor(public assetId: string) {
    super('预览构建失败');
  }
}

function log(err: Error) {
  if (err instanceof PreviewError) {
    console.log(`资产 ${err.assetId} 构建失败`);  // 访问子类属性
    return;
  }
  console.log(err.message);
}

const kinds = ['doc', 'post', 'note'] as const;
const k = kinds[Math.floor(Math.random() * 3)];   // 'doc' | 'post' | 'note'

if (k === 'doc') {
  // k 收窄为 'doc'
}

function first<T>(arr: T[]): T | undefined {
  return arr.length > 0 ? arr[0] : undefined;     // length 判断 + 严格索引收窄
}

// FANDEX 文档的三种加载状态，用字面量做「标签」
type DocState =
  | { status: 'loading' }
  | { status: 'error'; message: string }
  | { status: 'ready'; doc: DocMeta };

function render(state: DocState): string {
  switch (state.status) {
    case 'loading':
      return '加载中...';
    case 'error':
      return `出错了：${state.message}`;   // 只有这个分支能碰 message
    case 'ready':
      return state.doc.title;             // 只有这个分支能碰 doc
  }
}

function assertNever(x: never): never {
  throw new Error('漏了分支：' + JSON.stringify(x));
}

function render(state: DocState): string {
  switch (state.status) {
    case 'loading': return '加载中...';
    case 'error':   return `出错了：${state.message}`;
    case 'ready':   return state.doc.title;
    default:
      return assertNever(state);  // 漏写任何一个 case，这里编译报错
  }
}

function isDocMeta(value: unknown): value is DocMeta {
  return (
    typeof value === 'object' &&
    value !== null &&
    'title' in value && typeof (value as Record<string, unknown>).title === 'string' &&
    'wordCount' in value && typeof (value as Record<string, unknown>).wordCount === 'number' &&
    'tags' in value && Array.isArray((value as Record<string, unknown>).tags)
  );
}

// 用法：这一行同时完成「运行时检查」和「编译期收窄」
const raw: unknown = JSON.parse(localStorage.getItem('draft') ?? 'null');
if (isDocMeta(raw)) {
  console.log(raw.title.toUpperCase());   // raw 在这里被认作 DocMeta
} else {
  console.log('草稿已损坏，忽略');
}

function assertDocMeta(value: unknown): asserts value is DocMeta {
  if (!isDocMeta(value)) {
    throw new TypeError(`草稿格式损坏: ${JSON.stringify(value)}`);
  }
}

const raw: unknown = JSON.parse(localStorage.getItem('draft') ?? 'null');
assertDocMeta(raw);            // 通过之后
console.log(raw.title);        // raw 被永久收窄为 DocMeta（不需要 if 包裹）

function isString(x: unknown): boolean {
  return typeof x === 'string';
}

const mixed: (string | number)[] = ['a', 1, 'b'];
const strs = mixed.filter(isString);   // TS 5.5 前: (string | number)[]
                                       // TS 5.5 起: string[]，编译器自己推出谓词

if (typeof value === 'object' && value !== null) { ... }

interface User { email?: string }
const u: User = {};
if ('email' in u) {
  u.email?.toUpperCase();   // 'email' in u 为真，值仍可能是 undefined！
}

function isString(x: unknown): x is string {
  return typeof x === 'number';   // 编译通过，运行时全错
}

const strs = mixed.filter((x) => typeof x === 'string');  // 结果仍是 (string | number)[]

// 底层守卫函数族
function isObject(value: unknown): value is Record<string, unknown> {
  return typeof value === 'object' && value !== null;
}
function isString(value: unknown): value is string {
  return typeof value === 'string';
}
function isNumber(value: unknown): value is number {
  return typeof value === 'number';
}

// 组合守卫：先确认是对象，再逐字段校验
interface Person { name: string; age: number }
function isPerson(value: unknown): value is Person {
  return isObject(value) && isString(value.name) && isNumber(value.age);
}

function processValue(value: unknown): void {
  if (isPerson(value)) {
    console.log(`Person: ${value.name}, ${value.age}`); // 这里 value 已是 Person
  } else {
    console.log('Unknown type');
  }
}
processValue({ name: 'Alice', age: 30 }); // Person: Alice, 30
processValue(null);                        // Unknown type