模板字面量类型与类型体操

type Greeting = `hello ${string}`;
 
const a: Greeting = "hello world";   // OK
// const b: Greeting = "hi world";   // 报错：不匹配 hello 前缀

type Lang = "zh" | "en";
type Page = "home" | "about";
 
type Route = `/${Lang}/${Page}`;
// "/zh/home" | "/zh/about" | "/en/home" | "/en/about"

type Events = "click" | "focus" | "blur";
type Handlers = {
  [K in Events as `on${Capitalize<K>}`]: (e: unknown) => void;
};
// 等价于 { onClick: ...; onFocus: ...; onBlur: ... }

type Ev = "click" | "focus";
 
type Pretty = Capitalize<Ev>;   // "Click" | "Focus"
type Loud = Uppercase<Ev>;      // "CLICK" | "FOCUS"
 
const p: Pretty = "Click";
const l: Loud = "FOCUS";
console.log(p, l);
 
// 让运行时函数的返回类型和 Capitalize 精确对应
function capitalize<S extends string>(s: S): Capitalize<S> {
  return (s.charAt(0).toUpperCase() + s.slice(1)) as Capitalize<S>;
}
 
const r = capitalize("hello");   // 类型被推断为 "Hello"，不是 string
console.log(r);
 
// 用键重映射造一个事件处理器表
type Handlers = { [K in Ev as Capitalize<K>]: (n: number) => string };
const handlers: Handlers = {
  Click: (n) => "click:" + n,
  Focus: (n) => "focus:" + n,
};
console.log(handlers.Click(1), handlers.Focus(2));

type Prefix<S> = S extends `${infer P}-${string}` ? P : never;
type A = Prefix<"foo-bar">;   // "foo"

type SnakeToCamel<S extends string> =
  S extends `${infer Head}_${infer Tail}`
    ? `${Head}${Capitalize<SnakeToCamel<Tail>>}`
    : S;
 
type T1 = SnakeToCamel<"user_first_name">;   // "userFirstName"

type CamelKeys<T> = {
  [K in keyof T as K extends string ? SnakeToCamel<K> : K]: T[K];
};
 
type Row = { user_id: number; created_at: string };
type Model = CamelKeys<Row>;   // { userId: number; createdAt: string }

type Path<T> = T extends object
  ? { [K in keyof T & string]: K | `${K}.${Path<T[K]>}` }[keyof T & string]
  : never;
 
type Cfg = { server: { host: string; port: number }; debug: boolean };
type CfgPath = Path<Cfg>;
// "server" | "server.host" | "server.port" | "debug"

// 反转元组
type Reverse<T extends readonly unknown[]> =
  T extends readonly [infer H, ...infer R] ? [...Reverse<R>, H] : [];
 
const rev: Reverse<[1, 2, 3]> = [3, 2, 1];
console.log("Reverse:", JSON.stringify(rev));
 
// 取长度（元组的 length 是字面量类型）
type Length<T extends readonly unknown[]> = T["length"];
const n: Length<[string, number, boolean]> = 3;
console.log("Length:", n);
 
// 追加元素
type Push<T extends readonly unknown[], V> = [...T, V];
const pushed: Push<[1, 2], 3> = [1, 2, 3];
console.log("Push:", JSON.stringify(pushed));
 
// 取第一个 / 剩余
type Head<T extends readonly unknown[]> = T extends readonly [infer H, ...unknown[]] ? H : never;
type Tail<T extends readonly unknown[]> = T extends readonly [unknown, ...infer R] ? R : [];
 
const h: Head<[string, number]> = "first";
const t: Tail<[string, number, boolean]> = [7, true];
console.log("Head:", h, "Tail:", JSON.stringify(t));
 
// 运行时反转，类型层同步精确
function reverse<T extends readonly unknown[]>(arr: T): Reverse<T> {
  return arr.slice().reverse() as unknown as Reverse<T>;
}
console.log("运行时:", JSON.stringify(reverse([1, "a", true] as const)));

type DeepReadonly<T> =
  T extends (infer U)[] ? readonly DeepReadonly<U>[]
  : T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
  : T;
 
type DeepPartial<T> =
  T extends (infer U)[] ? DeepPartial<U>[]
  : T extends object ? { [K in keyof T]?: DeepPartial<T[K]> }
  : T;
 
type Config = {
  name: string;
  server: { host: string; port: number; tags: string[] };
};
 
const frozen: DeepReadonly<Config> = {
  name: "app",
  server: { host: "127.0.0.1", port: 8080, tags: ["a", "b"] },
};
// frozen.server.port = 1;  // 取消注释会报错：深层也是只读的
console.log("DeepReadonly:", frozen.server.host, frozen.server.port);
 
const patch: DeepPartial<Config> = { server: { port: 9090 } };
console.log("DeepPartial:", JSON.stringify(patch));
 
function deepFreeze<T>(o: T): DeepReadonly<T> {
  if (o !== null && typeof o === "object") {
    for (const v of Object.values(o as Record<string, unknown>)) deepFreeze(v);
    Object.freeze(o);
  }
  return o as unknown as DeepReadonly<T>;
}
const cfg = deepFreeze({ a: { b: 1 } });
console.log("已冻结:", Object.isFrozen(cfg.a), cfg.a.b);