Индексные типы TypeScript и ключевое слово keyof
Индексные типы и keyof — мощные инструменты в TypeScript для работы с типами объектов.
Они позволяют динамически обращаться к свойствам объекта и создавать гибкие сопоставления типов.
SVG-диаграмма: как работают индексные типы и keyof
Зачем нам нужны индексные типы?
В 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:Получить все ключи типа объекта
- Доступ по индексу:Получить типы свойств через ключи
- Сопоставленные типы:Создание новых типов на основе существующих типов
- Безопасность типов:Обеспечьте безопасность типов при динамическом доступе к свойствам
Другие расширенияРекомендация:Когда нужно работать со свойствами объекта, предпочитайте использовать индексные типы, чтобы сохранить безопасность типов.