TypeScript 对象

对象把相关的数据（属性）与行为（方法）打包在一起。TypeScript 中的对象由"结构"约束：声明了什么属性、各是什么类型，编译器都会逐项检查，杜绝随手往对象上挂字段带来的低级错误。

对象字面量与类型标注

// 直接给对象标注内联结构
const student: { name: string; age: number } = {
  name: "小明",
  age: 12,
};
console.log(student.name); // 输出：小明
// student.score = 95; // 报错：score 不在声明的结构里

属性简写与可选属性

const name = "张三";
const age = 30;
const user = { name, age }; // 属性简写，等价于 name: name
console.log(user); // 输出：{ name: '张三', age: 30 }

interface Options {
  label: string;
  size?: number; // 可选属性
}
const o: Options = { label: "确定" }; // 缺 size 合法
console.log(o.size); // 输出：undefined

对象中的方法

const calculator = {
  a: 6,
  b: 4,
  add(): number {
    return this.a + this.b; // 方法内的 this 指向对象自身
  },
};
console.log(calculator.add()); // 输出：10

嵌套对象与遍历

const shop = {
  name: "水果店",
  boss: { name: "老王", phone: "13800000000" }, // 嵌套对象
};
console.log(shop.boss.name); // 输出：老王

const scores: Record<string, number> = { 语文: 90, 数学: 85 };
for (const key of Object.keys(scores)) {
  console.log(`${key}=${scores[key]}`); // 依次输出：语文=90、数学=85
}

合并与拷贝

const base = { x: 1, y: 2 };
const copy = { ...base }; // 展开运算符：浅拷贝
copy.x = 99;
console.log(base.x, copy.x); // 输出：1 99

const merged = { ...base, z: 3 }; // 拷贝并新增属性
console.log(merged); // 输出：{ x: 1, y: 2, z: 3 }

const target = Object.assign({}, base, { y: 20 }); // 后者覆盖前者
console.log(target); // 输出：{ x: 1, y: 20 }

解构对象

const point = { x: 10, y: 20 };
const { x, y: py } = point; // 解构，并把 y 重命名为 py
console.log(x, py); // 输出：10 20

// 函数参数直接解构
function show({ x, y }: { x: number; y: number }): string {
  return `(${x}, ${y})`;
}
console.log(show(point)); // 输出：(10, 20)

小结

TypeScript 对象以"结构"为类型，属性、方法、嵌套、可选都能被编译器检查。日常多用字面量、展开、解构三大操作，配合 interface 或 Record 等类型，就能让对象既灵活又安全。