Bản thảo: loại kết hợp xuất phát từ mảng các đối tượng

Tôi muốn khai báo một mảng các mặt hàng được thi hành theo kiểu và có thể lấy được một loại kết hợp từ nó. Mẫu này hoạt động nếu bạn không cung cấp một loại rõ ràng cho các mục trong mảng. Tôi không chắc làm thế nào để giải thích tốt nhất vì vậy đây là một ví dụ:

VÍ DỤ 1

type Pair = {
  key: string;
  value: number;
};

const pairs: ReadonlyArray<Pair> = [
  { key: 'foo', value: 1 },
  { key: 'bar', value: 2 },
] as const;

type Keys = typeof pairs[number]['key']

VÍ DỤ 2

type Data = {
  name: string;
  age: number;
};

const DataRecord: Record<string, Data> = {
  foo: { name: 'Mark', age: 35 },
  bar: { name: 'Jeff', age: 56 },
} as const;

type Keys = keyof typeof DataRecord;

Dưới đây là một ví dụ về việc lấy các phím khi sử dụng as const. Tôi muốn hành vi tương tự nhưng với mảng được gõ rõ ràng.

const pairs = [
  { key: 'foo', value: 1 },
  { key: 'bar', value: 2 },
] as const;

type Keys = typeof pairs[number]['key']; // "foo" | "bar"

giá trị mong muốn của khóa: "foo"|"bar"

giá trị thực của các khóa: string

Đối với một biến, bạn có thể để trình biên dịch suy ra kiểu từ khởi tạo hoặc viết nó ra một cách rõ ràng. Nếu bạn viết nó một cách rõ ràng, như bạn có, thì giá trị khởi tạo được kiểm tra theo chú thích, nhưng loại thực tế của trình khởi tạo không ảnh hưởng đến loại biến (vì vậy bạn mất thông tin loại bạn muốn). Nếu bạn để trình biên dịch suy ra nó, bạn không còn có thể hạn chế loại để phù hợp với một giao diện cụ thể (như bạn muốn)

Giải pháp cho việc này là sử dụng một hàm chung để hạn chế giá trị và suy ra loại thực tế của nó:

type Pair = {
  key: string;
  value: number;
};
function craetePairsArray<T extends readonly Pair[] & Array<{key: V}>, V extends string>(...args: T) {
    return args
}

const pairs = craetePairsArray(
  { key: 'foo', value: 1 },
  { key: 'bar', value: 2 },
)

type Keys1 = typeof pairs[number]['key']

type Data = {
  name: string;
  age: number;
};

function craeteDataObject<T extends Record<string, Data>>(arg: T) {
    return arg;
}
const DataRecord = craeteDataObject({
  foo: { name: 'Mark', age: 35 },
  bar: { name: 'Jeff', age: 56 },
})

type Keys2 = keyof typeof DataRecord;

Liên kết sân chơi

Lưu ý: Đối với trường hợp mảng, chúng ta cần mạnh tay trình biên dịch một chút để suy ra các kiểu chữ chuỗi cho key, do đó, toàn bộ & Array<{key: V}>, trong đó Vmột tham số kiểu mở rộngstring

Các cách tiếp cận thông thường là:

• hãy để TS suy ra loại pairsbằng cách bỏ qua loại rõ ràng ReadonlyArray<Pair>(xem câu trả lời )
• cho keyvào Pairloại"foo"|"bar"

Nếu bạn không muốn làm điều này, thì cách duy nhất để suy ra các khóa của bạn và hạn chế loại pairslà sử dụng chức năng trợ giúp. Các Pairloại cũng sẽ được thực hiện chung để tiết kiệm cho keychuỗi các loại chữ. Bạn có thể sử dụng IIFE để thực hiện bài tập nhỏ gọn:

type Pair<K = string> = {
    key: K;
    value: number;
};

const pairs = (<T>(p: readonly Pair<T>[]) => p)([
    { key: 'foo', value: 1 },
    { key: 'bar', value: 2 },
] as const) // readonly Pair<"foo" | "bar">[]

type Keys = typeof pairs[number]['key'] // "foo" | "bar"

Sân chơi