在前面的文章中，我们介绍了 TypeScript 的基础数据类型（如 string、number、boolean 等），以及数组类型和元组类型。本文将继续深入探讨 TypeScript 的类型系统，重点讲解 对象类型、联合类型 和 类型别名 这三种高级类型：对象类型 用于描述具有多个属性的数据结构，联合类型 用于处理可能存在多种类型的情况，类型别名 则为复杂类型提供了简洁的命名方式。下面我们将逐一详细介绍它们的用法。

一、对象类型

1，基本概念

// 为参数 point 指定对象类型: {x: number, y: number}
function printPoint(point: { x: number; y: number }) {
  console.log(point.x);
  console.log(point.y);
}

// 调用函数，传入符合类型的对象
printPoint({ x: 200, y: 100 });

2，可选属性

// 为参数 point 指定对象类型，其中 z 属性为可选属性
function printPoint(point: { x: number; y: number; z?: number }) {
  console.log(point.x);
  console.log(point.y);
  
  // 可选属性可能不存在，需要判断后再使用
  if (point.z !== undefined) {
    console.log(point.z);
  }
}

// 不传递 z 属性也可以，因为 z 属性是可选的
printPoint({ x: 123, y: 321 });

// 传递 z 属性同样合法
printPoint({ x: 123, y: 321, z: 111 });

3，只读属性

// 使用 readonly 标记 id 属性为只读
interface User {
  readonly id: number;
  name: string;
  age: number;
}

// 创建用户对象
const user: User = {
  id: 1,
  name: "张三",
  age: 25
};

// 可以修改普通属性
user.name = "李四";  // 正常

// 尝试修改只读属性会报错
// user.id = 2;  // 错误：Cannot assign to 'id' because it is a read-only property

4，索引签名

// 使用索引签名定义可以动态添加字符串属性的对象
interface StringDictionary {
  // 索引签名：属性名是字符串，属性值也是字符串
  [key: string]: string;
}

const dict: StringDictionary = {
  name: "张三",
  city: "北京",
  job: "工程师"
};

// 可以动态添加新属性
dict.email = "zhangsan@example.com";  // 正常

// 错误：属性值类型必须匹配
// dict.age = 25;  // 错误：Type 'number' is not assignable to type 'string'

// 只读索引签名：所有属性都不能修改
interface ReadonlyDictionary {
  readonly [key: string]: string;
}

const readonlyDict: ReadonlyDictionary = {
  name: "张三",
  city: "北京"
};

// 正常读取
console.log(readonlyDict.name);  // 输出：张三

// 错误：只读索引签名不允许修改
// readonlyDict.name = "李四";  // 错误：Index signature in type 'ReadonlyDictionary' only permits reading

5，对象类型与 object 类型的区别

// object 类型：只能赋值为非原始类型
let obj: object;
obj = { name: "张三" };  // 正常
obj = [1, 2, 3];         // 正常（数组也是对象）
obj = function () {};    // 正常（函数也是对象）

// 错误：原始类型不能赋给 object
// obj = "string";  // 错误
// obj = 123;       // 错误
// obj = true;      // 错误

// ============ 分隔线 ============

// 对象类型：明确描述结构
let point: { x: number; y: number };
point = { x: 100, y: 200 };  // 正常

// 错误：缺少属性或类型不匹配
// point = { x: 100 };  // 错误：缺少 y 属性
// point = { x: "100", y: 200 };  // 错误：x 类型不匹配

二、联合类型

1，基本概念

// 将参数 id 指定为联合类型: number | string | boolean
function printID(id: number | string | boolean) {
  console.log("你的 id 是:", id);
}

// 可以传入 number 类型
printID(123);

// 可以传入 string 类型
printID("abc");

// 可以传入 boolean 类型
printID(true);

export {};

2，类型缩小

// 错误示例：直接调用 string 类型的方法
function printID(id: number | string | boolean) {
  // 错误：Property 'toUpperCase' does not exist on type 'number'
  console.log("你的 id 是:", id.toUpperCase());  // 因为 id 不一定是 string 类型
}

function printID(id: number | string | boolean) {
  // 使用联合类型的值时，需要特别小心
  // 通常需要进行类型缩小
  
  if (typeof id === "string") {
    // 类型缩小：TypeScript 知道这里 id 一定是 string 类型
    console.log(id.toUpperCase());  // 正常调用 string 方法
  } else if (typeof id === "number") {
    // TypeScript 知道这里 id 一定是 number 类型
    console.log(id.toFixed(2));  // 正常调用 number 方法
  } else {
    // TypeScript 知道这里 id 一定是 boolean 类型
    console.log(id ? "真" : "假");
  }
}

printID("hello");  // 输出：HELLO
printID(3.14159);  // 输出：3.14
printID(true);    // 输出：真

3，应用场景

// 定义结果类型：可能是成功结果，也可能是错误信息
type Result = string | Error;

function processData(data: string): Result {
  try {
    if (data.length === 0) {
      return new Error("数据为空");
    }
    return `处理成功：${data}`;
  } catch (e) {
    return new Error("处理失败");
  }
}

const result = processData("测试数据");

if (result instanceof Error) {
  console.log("错误：", result.message);
} else {
  console.log(result);
}

// 定义网络请求的多种状态类型
type NetworkLoadingState = { status: "loading" };
type NetworkFailedState = { status: "failed"; code: number };
type NetworkSuccessState = { status: "success"; response: string };

// 联合类型：表示网络请求可能处于三种状态之一
type NetworkState = NetworkLoadingState | NetworkFailedState | NetworkSuccessState;

function logger(state: NetworkState): string {
  // 根据状态属性进行类型缩小
  switch (state.status) {
    case "loading":
      return "请求加载中...";
    case "failed":
      return `请求失败，错误码：${state.code}`;  // TypeScript 知道这里有 code 属性
    case "success":
      return `请求成功：${state.response}`;  // TypeScript 知道这里有 response 属性
  }
}

console.log(logger({ status: "loading" }));
console.log(logger({ status: "failed", code: 404 }));
console.log(logger({ status: "success", response: "数据返回成功" }));

type Shape = "circle" | "square" | "triangle";

function getArea(shape: Shape): number {
  switch (shape) {
    case "circle":
      return Math.PI * 1 * 1;  // 假设半径为 1
    case "square":
      return 1 * 1;  // 假设边长为 1
    case "triangle":
      return 0.5 * 1 * 1;  // 假设底和高为 1
    default:
      // 检查是否所有情况都已处理
      // 如果有遗漏的 case，这里会报错
      const _exhaustiveCheck: never = shape;
      return _exhaustiveCheck;
  }
}

console.log(getArea("circle"));  // 输出：3.14159...

三、类型别名

1，基本概念

2，为对象类型定义别名

// 使用 type 定义类型别名
type PointType = {
  x: number;
  y: number;
  z?: number;  // 可选属性
};

// PointType 是对象类型的别名
function printPoint(point: PointType) {
  console.log(point.x);
  console.log(point.y);
  if (point.z !== undefined) {
    console.log(point.z);
  }
}

// 使用别名简化代码
printPoint({ x: 100, y: 200 });
printPoint({ x: 100, y: 200, z: 300 });

3，为联合类型定义别名

// IDType 是联合类型 string | number | boolean 的别名
type IDType = string | number | boolean;

// 使用别名简化参数类型定义
function printId(id: IDType) {
  console.log("ID 值为：", id);
}

printId(123);
printId("abc");
printId(true);

// 定义输入值类型
type InputValue = string | number | null | undefined;

// 定义用户角色类型
type UserRole = "admin" | "user" | "guest";

// 使用别名
function processInput(input: InputValue): string {
  if (input === null || input === undefined) {
    return "空值";
  }
  return String(input);
}

function checkRole(role: UserRole): boolean {
  return role === "admin";
}

console.log(processInput("测试"));  // 输出：测试
console.log(processInput(null));     // 输出：空值
console.log(checkRole("admin"));     // 输出：true
console.log(checkRole("user"));      // 输出：false

4，type 与 interface 的区别

// interface 的声明合并特性
interface Person {
  name: string;
}

interface Person {
  age: number;
}

// 两个同名 interface 会自动合并
const person: Person = {
  name: "张三",
  age: 25
};

console.log(person);

// ============ 分隔线 ============

// type 不支持声明合并
type Animal = {
  name: string;
};

// 下面这行会报错：Duplicate identifier 'Animal'
// type Animal = {
//   age: number;
// };

// type 使用交叉类型扩展
type AnimalWithAge = Animal & { age: number };

const animal: AnimalWithAge = {
  name: "小狗",
  age: 3
};

console.log(animal);