对象类型与接口

function print(user: { id: number; name: string }): void {
  console.log(user.id + " " + user.name);
}

interface User {
  id: number;
  name: string;
}

type User = {
  id: number;
  name: string;
};

interface User {
  id: number;
  name: string;
  email: string;
}
 
type Point = {
  x: number;
  y: number;
};
 
function greet(u: User): string {
  return "Hi, " + u.name + " (" + u.email + ")";
}
 
// 内联写法，适合一次性使用
function distance(a: Point, b: { x: number; y: number }): number {
  const dx = a.x - b.x;
  const dy = a.y - b.y;
  return Math.sqrt(dx * dx + dy * dy);
}
 
const ada: User = { id: 1, name: "Ada", email: "ada@example.com" };
console.log(greet(ada));
console.log("距离 = " + distance({ x: 0, y: 0 }, { x: 3, y: 4 }));
 
// 结构相同即兼容，不需要显式声明关系
const somePoint = { x: 6, y: 8, label: "P" };
console.log("到原点 = " + distance({ x: 0, y: 0 }, somePoint));

interface Config {
  host: string;
  port?: number;        // 类型实际是 number | undefined
}

function url(c: Config): string {
  const port = c.port ?? 80;      // 空值合并，只在 null/undefined 时取默认
  return c.host + ":" + port;
}

interface Account {
  readonly id: string;
  balance: number;
}
 
const acc: Account = { id: "A-1", balance: 100 };
acc.balance = 200;    // 可以
// acc.id = "A-2";    // 错误：无法分配到 id，因为它是只读属性

interface ServerConfig {
  readonly id: string;
  host: string;
  port?: number;
  tls?: boolean;
}
 
function toUrl(c: ServerConfig): string {
  const scheme = c.tls === true ? "https" : "http";
  const port = c.port ?? (c.tls === true ? 443 : 80);
  return scheme + "://" + c.host + ":" + port;
}
 
const dev: ServerConfig = { id: "dev", host: "localhost", port: 3000 };
const prod: ServerConfig = { id: "prod", host: "example.com", tls: true };
 
console.log(toUrl(dev));
console.log(toUrl(prod));
 
dev.host = "127.0.0.1";     // 普通属性可改
// dev.id = "x";            // 编译错误：id 是 readonly
console.log(toUrl(dev));
 
// ?? 与 || 的区别：配置项显式写了 0
const configured: number | undefined = 0;
console.log("用 ?? 得到 " + (configured ?? 8080));
console.log("用 || 得到 " + (configured || 8080));

interface StringMap {
  [key: string]: string;
}
 
const headers: StringMap = {};
headers["Content-Type"] = "application/json";

interface Mixed {
  [key: string]: string | number;
  name: string;      // string 是 string | number 的子类型，OK
  age: number;       // OK
  // ok: boolean;    // 错误：boolean 不能赋给 string | number
}

type Headers = Record<string, string>;
type Scores = Record<"math" | "english", number>;   // 两个键都必须有

interface CountMap {
  [word: string]: number;
}
 
function countWords(text: string): CountMap {
  const result: CountMap = {};
  for (const word of text.split(" ")) {
    const key = word.toLowerCase();
    result[key] = (result[key] || 0) + 1;
  }
  return result;
}
 
const counts = countWords("the cat and the hat and the bat");
console.log("the 出现 " + counts["the"] + " 次");
console.log("and 出现 " + counts["and"] + " 次");
console.log("不同单词 " + Object.keys(counts).length + " 个");
 
// Record 限定键集合，漏写一个键就报错
type Subject = "math" | "english";
const scores: Record<Subject, number> = { math: 92, english: 85 };
let total = 0;
for (const key of Object.keys(scores) as Subject[]) {
  total += scores[key];
}
console.log("平均分 = " + total / 2);

interface Animal {
  name: string;
}
 
interface Dog extends Animal {
  breed: string;
}

type Dog = Animal & { breed: string };

interface Window { title: string }
interface Window { version: number }
// 等价于 interface Window { title: string; version: number }

interface Animal {
  name: string;
  age: number;
}
 
interface Pet extends Animal {
  owner: string;
}
 
// 同名接口自动合并
interface Pet {
  vaccinated: boolean;
}
 
function intro(p: Pet): string {
  return p.name + "（" + p.age + " 岁），主人 " + p.owner +
    "，" + (p.vaccinated ? "已接种" : "未接种");
}
 
const dog: Pet = { name: "旺财", age: 3, owner: "小明", vaccinated: true };
console.log(intro(dog));
 
// 多重继承
interface Timestamped {
  createdAt: string;
}
interface Record2 extends Animal, Timestamped {}
 
const r: Record2 = { name: "小黑", age: 1, createdAt: "2024-01-01" };
console.log(r.name + " 建档于 " + r.createdAt);
 
// 用交叉类型表达同样的组合
type Combined = Animal & Timestamped & { tag: string };
const c: Combined = { name: "花花", age: 2, createdAt: "2024-05-01", tag: "cat" };
console.log(c.tag + ": " + c.name);

interface Opts { debug?: boolean }
 
// declare function run(o: Opts): void;
// run({ debug: true, verbose: true });   // 错误：verbose 不存在于 Opts
const o = { debug: true, verbose: true };
// run(o);                                 // 通过：走结构化兼容规则

type Anything = {};
const a: Anything = 42;        // 合法！
const b: Anything = "hello";   // 合法！
// const c: Anything = null;   // 不合法