Индексные типы TypeScript и ключевое слово keyof

Индексные типы и keyof — мощные инструменты в TypeScript для работы с типами объектов.

Они позволяют динамически обращаться к свойствам объекта и создавать гибкие сопоставления типов.


SVG-диаграмма: как работают индексные типы и keyof Background Title How Index Types and keyof Work The keyof Operator The keyof Operator type Keys = keyof User // "id" | "name" | "email" Arrow Index Access Types Index Access Types type Value = User["name"] // string Arrow Mapped Types Mapped Types type Partial<T> {[P in keyof T]?: T[P]} Lower half: Use cases Use Cases for Index Types Scenario 1 Dynamic property access Scenario 2 Type-safe object operations Scenario 3 Create generic utility types Arrow marker

Зачем нам нужны индексные типы?

В JavaScript нам часто нужно динамически обращаться к свойствам объекта.

Например, функции может понадобиться получить все ключи объекта или обратиться к соответствующему типу значения по ключу.

Индексные типы и keyof позволяют выразить эту динамичность в системе типов, сохраняя типобезопасность.

Концепция:Индексные типы — это класс типов, которые позволяют динамически обращаться к свойствам объекта, а keyof используется для получения объединённого типа, состоящего из всех ключей типа объекта.


Оператор keyof

Оператор keyof

Пример

// Определяем тип пользователя
interface User {
    id: number;       // ID пользователя
    name: string;     // Имя пользователя
    email: string;    // Электронная почта
    age?: number;     // Возраст (необязательно)
}

// Используйте keyof, чтобы получить объединённый тип всех ключей
// Результат: "id" | "name" | "email" | "age"
type UserKeys = keyof User;

// Проверка keyof
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
    return obj[key];
}

const user: User = {
    id: 1,
    name: "Alice",
    email: "alice@example.com"
};

// Получить свойство name
const userName: string = getProperty(user, "name");
console.log("Username: " + userName);

Вывод:

用户名: Alice

Объяснение:keyof возвращает объединённый тип литералов имён ключей, а не строковый тип.


Типы доступа по индексу

С помощью типов доступа по индексу можно получить тип свойства объекта.

Пример

// Определяем тип пользователя
interface User {
    id: number;
    name: string;
    email: string;
}

// Используйте типы доступа по индексу, чтобы получить типы свойств
type UserId = User["id"];      // number
type UserName = User["name"];  // string

// Можно использовать объединённый тип для доступа к нескольким ключам
type UserIdAndName = User["id" | "name"];  // number | string

// Используйте keyof, чтобы получить объединение всех типов свойств
type AllUserValues = User[keyof User];  // number | string

// Практический пример использования
function getValue<T, K extends keyof T>(obj: T, key: K): T[K] {
    return obj[key];
}

const user: User = { id: 1, name: "Bob", email: "bob@test.com" };

// Получить тип id
const idValue: number = getValue(user, "id");
console.log("ID: " + idValue);

// Получить тип name
const nameValue: string = getValue(user, "name");
console.log("Name: " + nameValue);

Доступ по индексу:С помощью квадратных скобок [] можно получить доступ к типу конкретного свойства объектного типа; это очень мощно и гибко.


Основы отображаемых типов

Сопоставленные типы позволяют создавать новые типы на основе существующих типов, перебирая все их ключи.

Пример

// Определяем тип пользователя
interface User {
    id: number;
    name: string;
    email: string;
    age: number;
}

// Сделать все свойства необязательными
type PartialUser = Partial<User>;

// Сделать все свойства только для чтения
type ReadonlyUser = Readonly<User>;

// Пользовательский сопоставленный тип: сделать все свойства необязательными и преобразовать их в строки
type Stringify<T> = {
    [P in keyof T]: string;
};

type StringifiedUser = Stringify<User>;

// Практический пример использования
const partialUser: PartialUser = {
    id: 1,
    name: "Alice"
    // email и age необязательны
};

const readonlyUser: ReadonlyUser = {
    id: 1,
    name: "Bob",
    email: "bob@test.com",
    age: 25
};
// readonlyUser.name = "Charlie"; // Ошибка: readonly

console.log("Пользователь Partial: " + partialUser.name);
console.log("Пользователь Readonly: " + readonlyUser.name);

Сопоставленные типы:Использование синтаксиса [P in keyof T] для перебора всех ключей типа — основа для создания служебных типов.


Ограничение типа ключей

Используйте keyof и обобщённые ограничения, чтобы ограничить ключи, которые принимает функция.

Пример

// Определите тип конфигурации
interface Config {
    apiUrl: string;
    timeout: number;
    retry: boolean;
}

// Можно получить только существующие ключи
function getConfigValue<T, K extends keyof T>(
    config: T,
    key: K
): T[K] {
    return config[key];
}

// Определяем конфигурацию
const config: Config = {
    apiUrl: "https://api.example.com",
    timeout: 5000,
    retry: true
};

// Верно: ключ существует
const url: string = getConfigValue(config, "apiUrl");
const timeoutVal: number = getConfigValue(config, "timeout");

// Ошибка: ключ не существует (TypeScript сообщит об ошибке)
// const invalid = getConfigValue(config, "unknown");

console.log("API URL: " + url);
console.log("Timeout: " + timeoutVal);

Ограничение:K extends keyof T гарантирует, что переданный ключ должен быть ключом, существующим у объекта, что предотвращает ошибки во время выполнения.


Получение только свойств определённого типа

Извлечение ключей свойств определённого типа из типа объекта.

Пример

// Определяем смешанный тип
interface Mixed {
    id: number;
    name: string;
    age: number;
    email: string;
    active: boolean;
}

// Извлечь все ключи строкового типа
type StringKeys<T> = {
    [K in keyof T]: T[K] extends string ? K : never;
}[keyof T];

// Извлечь все ключи типа number
type NumberKeys<T> = {
    [K in keyof T]: T[K] extends number ? K : never;
}[keyof T];

// Тест
type StringProps = StringKeys<Mixed>;  // "name" | "email"
type NumberProps = NumberKeys<Mixed>;  // "id" | "age"

// Практическое применение: получить значение строкового свойства
function getStringProps<T, K extends StringKeys<T>>(
    obj: T,
    keys: K[]
): T[K][] {
    return keys.map(key => obj[key]);
}

const mixed: Mixed = {
    id: 1,
    name: "Alice",
    age: 25,
    email: "alice@test.com",
    active: true
};

const strings = getStringProps(mixed, ["name", "email"]);
console.log("Свойства строк: " + strings.join(", "));

Условные типы:Комбинирование условных типов и отображаемых типов позволяет выполнять сложную фильтрацию и извлечение типов.


Итерация по типам массивов

Используйте индексные типы для манипулирования массивами и кортежами.

Пример

// Определите тип кортежа
type Tuple = [string, number, boolean];

// Получить тип элемента кортежа
type First = Tuple[0];   // string
type Second = Tuple[1];  // number
type Third = Tuple[2];   // boolean

// Используйте number для получения типа всех элементов
type AllElements = Tuple[number];  // string | number | boolean

// Получить тип элемента массива
type StringArray = string[];
type ArrayElement = StringArray[number];  // string

// Практическое применение: перегрузки функций
function getElement<T extends any[]>(
    arr: T,
    index: number
): T[indexof T] | undefined {
    return index < arr.length ? arr[index] : undefined;
}

const tuple: Tuple = ["hello", 123, true];
const arr: string[] = ["a", "b", "c"];

console.log("Элемент кортежа + getElement(tuple, 0));
console.log("Элемент массива + getElement(arr, 1));

Индексация кортежей:Кортежи могут использовать числовые индексы, и каждый индекс соответствует определённому типу элемента, чего не могут делать массивы.


Примечания

  • keyof возвращает тип объединения:keyof возвращает тип объединения литералов имён ключей
  • Безопасность доступа по индексу:Убедитесь, что ключ, к которому осуществляется доступ, существует в целевом типе
  • Ограничения обобщений:Используйте extends keyof для ограничения параметров обобщения
  • Сопоставленные типы требуют ключевого слова in:Сопоставленные типы используют синтаксис [P in keyof T]

Лучшие практики:Индексные типы — краеугольный камень создания обобщённых служебных типов; их освоение может значительно улучшить ваши навыки работы с типами.


Итог

Индексные типы и keyof — важные компоненты системы типов TypeScript.

  • keyof:Получить все ключи типа объекта
  • Доступ по индексу:Получить типы свойств через ключи
  • Сопоставленные типы:Создание новых типов на основе существующих типов
  • Безопасность типов:Обеспечьте безопасность типов при динамическом доступе к свойствам

Рекомендация:Когда нужно работать со свойствами объекта, предпочитайте использовать индексные типы, чтобы сохранить безопасность типов.

Другие расширения