TypeScript 对象类型：可选属性与只读属性

TypeScript 对象类型列出对象拥有的属性以及每个属性的类型：{ name: string; age: number }。加上 ? 让属性变为可选，加上 readonly 防止属性被重新赋值。可以内联写出类型，也可以用 type 或 interface 给它命名以便复用。

// Inline object type
let point: { x: number; y: number } = { x: 3, y: 4 };

// Named object type with optional and readonly properties
type User = {
    readonly id: number;
    name: string;
    email?: string; // optional: may be missing
};

const ada: User = { id: 1, name: "Ada" };
const grace: User = { id: 2, name: "Grace", email: "grace@example.com" };

console.log(point.x + point.y);           // 7
console.log(ada.email ?? "no email");      // no email
console.log(grace.email?.toUpperCase());   // GRACE@EXAMPLE.COM

编写对象类型

属性之间用 ; 或 , 分隔（两者都可以，; 是常见风格），单独换行也可以。只用一次的参数用内联类型没有问题；用到两次以上的，就给它起个名字。

// Inline, in a parameter
function area(rect: { width: number; height: number }): number {
    return rect.width * rect.height;
}

// Named with a type alias
type Rect = { width: number; height: number };

// Named with an interface (the same shape)
interface RectShape {
    width: number;
    height: number;
}

type 和 interface 描述对象形状的能力一样好。它们的区别（声明合并、联合类型）见 interface 与 type 页面。

访问类型中没有声明的属性会导致编译错误：point.z 报 TS2339：Property 'z' does not exist on type '{ x: number; y: number; }'.

可选属性

名字后面的 ? 让这个属性可以省略。读取可选属性得到 T | undefined，所以 TypeScript 会要求你在使用之前处理缺失的情况。

type Profile = {
    name: string;
    nickname?: string;
    age?: number;
};

function greet(p: Profile): string {
    // p.nickname is string | undefined
    const shown = p.nickname ?? p.name;         // default with ??
    const ageText = p.age !== undefined ? ` (${p.age})` : ""; // or check
    return `Hi, ${shown}${ageText}`;
}

console.log(greet({ name: "Ada" }));                        // Hi, Ada
console.log(greet({ name: "Grace", nickname: "Amazing Grace", age: 85 }));
console.log("age" in { name: "Ada" });                      // false

不加检查就调用可选属性上的方法会报错：p.nickname.toUpperCase() 报 TS18048：'p.nickname' is possibly 'undefined'.。如果可以接受 undefined 作为结果，就使用可选链（p.nickname?.toUpperCase()）。

prop?: T 和 prop: T | undefined 并不相同。前者允许这个键不存在；后者要求这个键存在，只是它的值可以是 undefined：

type A = { note?: string };
type B = { note: string | undefined };

const a1: A = {};                    // fine: key left out
const b1: B = { note: undefined };   // fine: key present
// @ts-expect-error: Property 'note' is missing in type '{}' but required in type 'B'.
const b2: B = {};

console.log(a1, b1, b2); // {} { note: undefined } {}

只读属性

readonly 禁止在对象创建之后重新给属性赋值。它只是编译时的检查，而且是浅层的：存放在只读属性中的对象或数组，其内部仍然可以修改。

type Order = {
    readonly id: string;
    readonly items: string[];
    status: "open" | "paid";
};

const order: Order = { id: "A-17", items: ["tea"], status: "open" };

order.status = "paid"; // fine
// @ts-expect-error: Cannot assign to 'id' because it is a read-only property.
order.id = "B-2";
order.items.push("cake"); // allowed: readonly is shallow

console.log(order); // { id: 'B-2', items: [ 'tea', 'cake' ], status: 'paid' }

输出展示了这两个限制：id 在运行时确实被改掉了（只有编译器知道它是只读的），内部的数组也被修改了。只读数组用 readonly string[]；要一次性让所有属性只读，用 Readonly<Order>。

多余属性检查

当你把对象字面量直接赋给带类型的变量，或者直接传给带类型的参数时，TypeScript 会拒绝类型中没有声明的任何属性。新创建的字面量里出现额外属性，几乎都是拼写错误。

// This does not compile: 'colour' is not a property of Options.
type Options = { color?: string; size?: number };

function draw(opts: Options) {
    console.log(opts.color ?? "black", opts.size ?? 1);
}

draw({ colour: "red", size: 2 });

index.ts(8,8): error TS2561: Object literal may only specify known properties, but 'colour' does not exist in type 'Options'. Did you mean to write 'color'?

这里是 TS2561，因为编译器找到了相近的属性名；如果多出的属性没有相似的名字，就会报 TS2353：Object literal may only specify known properties, and 'z' does not exist in type 'Point'.。如果没有这项检查，拼写错误就能编译通过，color 会是 undefined，程序会悄无声息地用黑色绘制。这项检查只针对新创建的字面量。已经存放在变量中的对象可以带有额外属性，因为 TypeScript 的类型是结构化的：只要一个值至少具备所需的属性，它就符合这个类型。

type Point = { x: number; y: number };

const point3d = { x: 1, y: 2, z: 3 };
const p: Point = point3d; // fine: point3d has x and y

function show(pt: Point) {
    console.log(pt.x, pt.y);
}
show(point3d); // 1 2

嵌套对象与方法

对象类型可以嵌套，也可以用方法语法或函数类型的属性来描述方法。

type Company = {
    name: string;
    address: {
        city: string;
        zip?: string;
    };
    tags: string[];
    describe(): string;                  // method syntax
    rename: (newName: string) => void;   // function property
};

const acme: Company = {
    name: "Acme",
    address: { city: "Berlin" },
    tags: ["b2b"],
    describe() {
        return `${this.name} in ${this.address.city}`;
    },
    rename(newName) {
        this.name = newName;
    },
};

acme.rename("Acme GmbH");
console.log(acme.describe());               // Acme GmbH in Berlin
console.log(acme.address.zip ?? "no zip");  // no zip

type Address = Company["address"]; // reuse a nested type by indexing
const home: Address = { city: "Paris", zip: "75001" };
console.log(home);

对于层级深或需要复用的形状，给内层类型命名（type Address = { ... }）并引用它，或者像最后几行那样，用索引访问 Company["address"] 从外层类型中取出它。

object、{} 与 Object

有三个类型听起来很像，含义却各不相同：

const a: object = { id: 1 };
const b: object = [1, 2];
const c: {} = 42;          // allowed: {} does not mean "empty object"
const d: {} = "text";      // allowed too

// @ts-expect-error: Type 'number' is not assignable to type 'object'.
const e: object = 42;

console.log(a, b, c, d, e);

{} 的意思不是“空对象”，而是“不是 null 或 undefined”。要接受键未知的任意对象，使用 Record<string, unknown>；要表示键到值的映射，使用索引签名或 Record，见 字典 页面。大多数时候，具体的形状比这三个类型都要好。