数组、元组与枚举

const a: number[] = [1, 2, 3];
const b: Array<number> = [1, 2, 3];    // 泛型写法，完全等价

const c: (string | number)[] = [1, "two"];   // 必须加括号
const d: Array<string | number> = [1, "two"]; // 更清晰

const arr = [1, 2, 3];
const x = arr[99];      // TS 认为 x 是 number，实际运行时是 undefined

const nums: readonly number[] = [1, 2, 3];
// nums.push(4);      // 错误：只读数组上不存在 push
const bigger = [...nums, 4];   // 正确：创建新数组

const scores: number[] = [88, 92, 79];
const tags: Array<string> = ["ts", "js"];
const mixed: (string | number)[] = [1, "two", 3];
 
scores.push(100);
console.log("scores = " + scores.join(", "));
console.log("tags = " + tags.join("/"));
console.log("mixed 长度 = " + mixed.length);
 
// 只读数组：函数承诺不修改入参
function sum(values: readonly number[]): number {
  // values.push(0);  // 编译错误：只读
  return values.reduce((acc, v) => acc + v, 0);
}
console.log("总分 = " + sum(scores));
 
const frozen: readonly string[] = ["a", "b"];
const extended = [...frozen, "c"];   // 用展开创建新数组
console.log("extended = " + extended.join(""));
 
// 常用高阶方法的类型都会正确推断
const doubled = scores.map((s) => s * 2);
const passed = scores.filter((s) => s >= 90);
console.log("doubled = " + doubled.join(","));
console.log("passed = " + passed.join(","));

let pair: [string, number] = ["age", 30];
pair[0].toUpperCase();   // TS 知道第 0 位是 string
// pair = ["age"];        // 错误：长度不匹配

type Range = [start: number, end: number];
type HttpResult = [status: number, body: string];

type Point = [x: number, y: number, z?: number];       // z 可选
type Command = [name: string, ...args: string[]];      // 后面可以跟任意多个

type Point = [x: number, y: number, z?: number];
type Command = [name: string, ...args: string[]];
 
const p2: Point = [3, 4];
const p3: Point = [3, 4, 5];
 
function norm(p: Point): number {
  const z = p[2] ?? 0;
  return Math.sqrt(p[0] * p[0] + p[1] * p[1] + z * z);
}
console.log("2D 长度 = " + norm(p2));
console.log("3D 长度 = " + norm(p3).toFixed(4));
 
const cmd: Command = ["git", "commit", "-m", "init"];
const [bin, ...rest] = cmd;             // 解构，rest 推断为 string[]
console.log("命令 = " + bin + "，参数 " + rest.length + " 个");
 
// 元组常用于「返回多个值」
function divide(a: number, b: number): [quotient: number, remainder: number] {
  return [Math.floor(a / b), a % b];
}
const [q, r] = divide(17, 5);
console.log("17 / 5 = " + q + " 余 " + r);
 
// as const 会把数组字面量推断成只读元组
const rgb = [255, 128, 0] as const;
console.log("rgb 第一位 = " + rgb[0] + "，长度固定为 " + rgb.length);

enum Direction {
  Up,      // 0
  Down,    // 1
  Left,    // 2
  Right,   // 3
}

enum Status {
  Pending = "PENDING",
  Success = "SUCCESS",
  Failed = "FAILED",
}

enum Direction {
  Up,
  Down,
  Left,
  Right,
}
 
enum Status {
  Pending = "PENDING",
  Success = "SUCCESS",
  Failed = "FAILED",
}
 
console.log("Direction.Left = " + Direction.Left);
console.log("反向映射 Direction[2] = " + Direction[2]);
console.log("Status.Success = " + Status.Success);
 
function move(d: Direction): string {
  switch (d) {
    case Direction.Up:
      return "向上";
    case Direction.Down:
      return "向下";
    case Direction.Left:
      return "向左";
    case Direction.Right:
      return "向右";
  }
}
console.log(move(Direction.Up) + " / " + move(Direction.Right));
 
function label(s: Status): string {
  if (s === Status.Pending) return "处理中";
  if (s === Status.Success) return "已完成";
  return "失败";
}
console.log(label(Status.Pending) + "，" + label(Status.Failed));
 
// 枚举也是一个真实存在的对象，可以遍历字符串枚举的键
const allStatus = Object.values(Status);
console.log("共有 " + allStatus.length + " 种状态: " + allStatus.join(","));

const enum Level {
  Low = 1,
  High = 2,
}
const l = Level.High;   // 编译产物直接是 const l = 2

const Status = {
  Pending: "PENDING",
  Success: "SUCCESS",
} as const;
 
type Status = (typeof Status)[keyof typeof Status];  // "PENDING" | "SUCCESS"