---
sidebar_position: 3
---

# Utility types
**Utility Types** в TypeScript — это встроенные generic-типы, которые предоставляют удобные способы для преобразования или манипуляции существующими типами. Они упрощают работу с типами, позволяя создавать новые типы на основе существующих без необходимости писать сложные конструкции вручную.

Utility Types часто используются для создания производных типов, таких как частичные объекты, обязательные поля, исключение полей и т.д. Они особенно полезны в больших проектах, где требуется гибкость и повторное использование типов.

## Список популярных Utility Types

### 1. Partial\<T>
Создает тип, в котором все свойства **`T`** становятся необязательными.

```ts
interface User {
  name: string;
  age: number;
}

type PartialUser = Partial<User>;
// { name?: string; age?: number; }
```

### 2. Required\<T>
Создает тип, в котором все свойства **`T`** становятся обязательными.

```ts
interface User {
  name?: string;
  age?: number;
}

type RequiredUser = Required<User>;
// { name: string; age: number; }
```

### 3. Readonly\<T>
Создает тип, в котором все свойства **`T`** доступны только для чтения.
```ts
interface User {
  name: string;
  age: number;
}

type ReadonlyUser = Readonly<User>;
// { readonly name: string; readonly age: number; }
```

### 4. Record\<K, T>
Создает тип, представляющий объект, где ключи имеют тип **`K`**, а значения — тип **`T`**.
```ts
type UserRoles = Record<string, string>;
// { [key: string]: string }

const roles: UserRoles = {
  admin: "Admin",
  user: "User",
};
```

### 5. Pick\<T, K>
Создает тип, выбирая только указанные свойства **`K`** из типа **`T`**.
```ts
interface User {
  name: string;
  age: number;
  email: string;
}

type UserNameAndAge = Pick<User, "name" | "age">;
// { name: string; age: number; }
```

### 6. Omit\<T, K>
Создает тип, исключая указанные свойства **`K`** из типа **`T`**.
```ts
interface User {
  name: string;
  age: number;
  email: string;
}

type UserWithoutEmail = Omit<User, "email">;
// { name: string; age: number; }
```

### 7. Exclude\<T, U>
Исключает из типа **`T`** все типы, которые можно присвоить **`U`**.
```ts
type T = string | number | boolean;
type StringOrNumber = Exclude<T, boolean>;
// string | number
```

### 8. Extract\<T, U>
Извлекает из типа **`T`** только те типы, которые можно присвоить **`U`**.
```ts
type T = string | number | boolean;
type OnlyBoolean = Extract<T, boolean>;
// boolean
```

### 9. NonNullable\<T>
Удаляет `null` и `undefined` из типа **`T`**.
```ts
type T = string | number | null | undefined;
type NonNullableT = NonNullable<T>;
// string | number
```

### 10. ReturnType\<T>
Создает тип, представляющий тип возвращаемого значения функции **`T`**.
```ts
function getUser() {
  return { name: "John", age: 30 };
}

type UserReturnType = ReturnType<typeof getUser>;
// { name: string; age: number; }
```

### 11. Parameters\<T>
Создает тип, представляющий кортеж параметров функции **`T`**.
```ts
function add(a: number, b: number) {
  return a + b;
}

type AddParams = Parameters<typeof add>;
// [a: number, b: number]
```

### 12. ConstructorParameters\<T>
Создает тип, представляющий кортеж параметров конструктора класса **`T`**.
```ts
class User {
  constructor(public name: string, public age: number) {}
}

type UserConstructorParams = ConstructorParameters<typeof User>;
// [name: string, age: number]
```

### 13. InstanceType\<T>
Создает тип, представляющий тип экземпляра класса **`T`**.
```ts
class User {
  name: string;
  age: number;
}

type UserInstance = InstanceType<typeof User>;
// User
```

### 14. ThisParameterType\<T>
Извлекает тип параметра **`this`** из функции **`T`**.
```ts
function greet(this: { name: string }) {
  console.log(`Hello, ${this.name}`);
}

type GreetThisType = ThisParameterType<typeof greet>;
// { name: string }
```

### 15. OmitThisParameter\<T>
Создает тип функции, удаляя параметр **`this`**.
```ts
function greet(this: { name: string }) {
  console.log(`Hello, ${this.name}`);
}

type GreetWithoutThis = OmitThisParameter<typeof greet>;
// () => void
```


## Примеры использования Utility Types
#### Пример 1: Создание частичного объекта
```ts
interface User {
  name: string;
  age: number;
  email: string;
}

type PartialUser = Partial<User>;
// { name?: string; age?: number; email?: string; }
```
#### Пример 2: Выбор конкретных свойств
```ts
interface User {
  name: string;
  age: number;
  email: string;
}

type UserNameAndEmail = Pick<User, "name" | "email">;
// { name: string; email: string; }
```
#### Пример 3: Исключение свойств
```ts
interface User {
  name: string;
  age: number;
  email: string;
}

type UserWithoutEmail = Omit<User, "email">;
// { name: string; age: number; }
```

## Итог
**Utility Types** в TypeScript — это мощный инструмент для работы с типами. Они позволяют:

- Упрощать создание новых типов на основе существующих.
- Уменьшать дублирование кода.
- Повышать читаемость и поддерживаемость кода.

Использование **Utility Types** делает TypeScript более гибким и выразительным, особенно в больших проектах.