核心概念：类型系统的零件

// —— 你写的 .ts（类型世界 + 值世界都在）——
let count: number = 5;
function greet(name: string): string {
  return "Hi, " + name;
}

// —— tsc 编译后的 .js（类型世界被擦干净）——
// let count = 5;
// function greet(name) {
//   return "Hi, " + name;
// }

let price: number = 10;     // 整数也是 number
let ratio: number = 0.5;    // 小数也是 number
console.log(0.1 + 0.2);     // 0.30000000000000004，不是 0.3
console.log(0.1 + 0.2 === 0.3);  // false

const big: bigint = 9007199254740993n;  // 超出安全整数范围才用 bigint

// 边界：参数与返回值显式注解（契约）
function totalPrice(items: { price: number }[]): number {
  let sum = 0;            // 内部：推断为 number，不用标
  for (const it of items) sum += it.price;
  return sum;
}

let name = "Ada";         // 推断为 string
let ids = [1, 2, 3];      // 推断为 number[]

interface User {
  id: number;
  name: string;
  email?: string;        // ? 表示可选属性
  readonly createdAt: number;  // readonly：初始化后不可改
}

type Point = { x: number; y: number };  // type 也能描述对象形状

function rename(u: User, next: string): User {
  return { ...u, name: next };
}

type Method = "GET" | "POST" | "PUT" | "DELETE";

function request(url: string, method: Method): void {
  // ...
}

request("/users", "POST");   // ✓
request("/users", "PATCH");  // ✗ 编译报错："PATCH" 不在联合里

type Id = string | number;   // 联合不同原始类型也很常见

function send(url: string, retries: number = 3, ...tags: string[]): boolean {
  return true;
}
//  retries 有默认值；...tags 是剩余参数（收成 string[]）

// 函数也能作为类型标注（回调）
function onClick(handler: (event: string) => void): void {
  handler("tap");
}

class Counter {
  count = 0;
  increment() { this.count++; }            // 普通方法
  incrementSafe = () => { this.count++; };  // 箭头函数：锁定词法 this
}

const c = new Counter();
[1, 2, 3].forEach(c.increment);      // ✗ this 变成 undefined，运行时报错
[1, 2, 3].forEach(c.incrementSafe);  // ✓ 箭头函数保留了 c 作为 this

function first<T>(arr: T[]): T | undefined {
  return arr[0];
}
const a = first([1, 2, 3]);     // a: number | undefined
const b = first(["x", "y"]);    // b: string | undefined

// 约束：T 必须有 id 字段
function byId<T extends { id: number }>(items: T[], id: number): T | undefined {
  return items.find(it => it.id === id);
}

function format(value: string | number): string {
  if (typeof value === "string") {
    return value.toUpperCase();   // 这一支里 value 是 string
  }
  return value.toFixed(2);        // 另一支里 value 是 number
}

// in：靠属性是否存在来收窄
type Dog = { bark: () => void };
type Cat = { meow: () => void };
function speak(a: Dog | Cat) {
  if ("bark" in a) a.bark(); else a.meow();
}

// 带标签的联合（discriminated union）——最稳的收窄
type Result =
  | { kind: "ok"; data: string }
  | { kind: "err"; message: string };
function handle(r: Result) {
  if (r.kind === "ok") console.log(r.data);
  else console.log(r.message);
}