掌握 TypeScript 模板文字类型：提高代码安全性和表现力

type greeting<t extends string> = `hello, ${t}!`;
type result = greeting<"world">; // "hello, world!"

type snaketocamel<s extends string> = s extends `${infer t}_${infer u}`
  ? `${t}${capitalize<snaketocamel<u>>}`
  : s;

type result = snaketocamel<"hello_world_typescript">; // "helloworldtypescript"

type table = "users" | "posts" | "comments";
type column = "id" | "name" | "email" | "content";

type select<t extends table, c extends column> = `select ${c} from ${t}`;
type where<t extends string> = `where ${t}`;

type query<t extends table, c extends column, w extends string> = 
  `${select<t, c>} ${where<w>}`;

type userquery = query<"users", "name" | "email", "id = 1">; 
// "select name, email from users where id = 1"

type digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
type adddigits<a extends digit, b extends digit> = 
  // ... (implementation details omitted for brevity)

type add<a extends string, b extends string> = 
  // ... (implementation details omitted for brevity)

type result = add<"123", "456">; // "579"

type form = {
  name: string;
  email: string;
  age: number;
};

type validationrule<t> = t extends string
  ? "isstring"
  : t extends number
  ? "isnumber"
  : never;

type validationschema<t> = {
  [k in keyof t]: validationrule<t[k]>;
};

type formvalidation = validationschema<form>;
// { name: "isstring", email: "isstring", age: "isnumber" }

type chainable<t> = {
  set: <k extends string, v>(key: k, value: v) => chainable<t & { [p in k]: v }>;
  get: () => t;
};

declare function createchainable<t>(): chainable<t>;

const result = createchainable()
  .set("foo", 123)
  .set("bar", "hello")
  .get();

// result type: { foo: number, bar: string }

type shallowpartial<t> = {
  [p in keyof t]?: t[p] extends object ? t[p] : t[p] | undefined;
};

type user = {
  name: string;
  address: {
    street: string;
    city: string;
  };
};

type partialuser = shallowpartial<user>;
// {
//   name?: string | undefined;
//   address?: {
//     street: string;
//     city: string;
//   } | undefined;
// }

type assertequal<t, u> = t extends u
  ? u extends t
    ? true
    : `expected ${u}, but got ${t}`
  : `expected ${u}, but got ${t}`;

type test1 = assertequal<"hello", "hello">; // true
type test2 = assertequal<"hello", "world">; // "expected "world", but got "hello""

type eventmap = {
  "user:login": { userid: string };
  "item:added": { itemid: number; quantity: number };
};

type eventname = keyof eventmap;

class typedeventemitter<t extends record<string, any>> {
  emit<e extends eventname>(event: e, data: t[e]): void {
    // implementation details omitted
  }

  on<e extends eventname>(event: e, callback: (data: t[e]) => void): void {
    // implementation details omitted
  }
}

const emitter = new typedeventemitter<eventmap>();

emitter.emit("user:login", { userid: "123" }); // ok
emitter.emit("item:added", { itemid: 456, quantity: 2 }); // ok
emitter.emit("user:login", { itemid: 789 }); // type error!

type State = "idle" | "loading" | "success" | "error";

type Event = "fetch" | "success" | "failure" | "reset";

type Transition<S extends State, E extends Event> =
  S extends "idle"
    ? E extends "fetch"
      ? "loading"
      : S
    : S extends "loading"
    ? E extends "success"
      ? "success"
      : E extends "failure"
      ? "error"
      : S
    : S extends "success" | "error"
    ? E extends "reset"
      ? "idle"
      : S
    : never;

type Machine<S extends State = "idle"> = {
  state: S;
  transition: <E extends Event>(event: E) => Machine<Transition<S, E>>;
};

declare function createMachine<S extends State>(initialState: S): Machine<S>;

const machine = createMachine("idle")
  .transition("fetch")
  .transition("success")
  .transition("reset");

type FinalState = typeof machine.state; // "idle"