Что такое Omit в TypeScript

Omit нужен, когда у вас уже есть тип и вы хотите получить похожий тип, но без части свойств.

type User = {
  id: string;
  name: string;
  email: string;
  passwordHash: string;
};

type PublicUser = Omit<User, "passwordHash">;

const userForUi: PublicUser = {
  id: "u1",
  name: "Ada",
  email: "ada@example.com",
};

На интервью не останавливайтесь на фразе, что Omit исключает поля. Сразу уточните, что исключение происходит в системе типов. JavaScript-объект от этого не меняется.

Упрощенно Omit можно прочитать так: взять все ключи исходного типа, исключить ненужные, потом собрать тип из оставшихся ключей.

type MyOmit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

Exclude убирает ключи из union, а Pick выбирает оставшиеся свойства из T. Поэтому Omit сохраняет типы значений и модификаторы свойств, например readonly и ?.

Практический вывод такой. Omit хорош для производных контрактов, но он не заменяет понимание исходного типа. Если вы исключили обязательное поле и потом передали результат туда, где ждут полный User, TypeScript правильно начнет ругаться.

Omit удобен, когда тип большой, а убрать нужно один или несколько известных ключей. Например, для props компонента, где вы переиспользуете тип доменной сущности, но не хотите принимать служебные поля.

Pick часто лучше для публичных DTO. Если наружу разрешено отдать только три поля, allowlist через Pick снижает риск, что новое поле в исходном типе случайно станет частью публичного контракта.

Runtime-преобразование нужно, когда вы работаете с реальными данными. Типы помогают заметить ошибку в коде, но не фильтруют объект сами. Для frontend это особенно важно перед fetch, записью в state, отправкой аналитики и передачей props через spread.

Первый нюанс: стандартный Omit не всегда защищает от опечатки в ключе.

type User = {
  id: string;
  password: string;
};

type PublicUser = Omit<User, "passwrod">;

Такой тип может остаться почти тем же User, потому что ключ написан неверно. Если в команде важно ловить такие ошибки, можно сделать строгий helper.

type StrictOmit<T, K extends keyof T> = Omit<T, K>;

type SafePublicUser = StrictOmit<User, "password">;

Второй нюанс: Omit не глубокий. Он не удалит поле внутри вложенного объекта. Для вложенной структуры нужно отдельно описать вложенный тип или аккуратно собрать новый тип через mapped types.

Третий нюанс: union-типы. Если у вас есть несколько вариантов состояния UI, обычный Omit может не примениться к каждой ветке так, как вы ожидаете.

type Success = { status: "success"; data: string; meta: string };
type ErrorState = { status: "error"; error: string; meta: string };
type State = Success | ErrorState;

type StateWithoutMeta = Omit<State, "meta">;

Если нужно убрать поле из каждой ветки union, часто используют дистрибутивный вариант.

type DistributiveOmit<T, K extends keyof any> = T extends unknown
  ? Omit<T, K>
  : never;

type BetterState = DistributiveOmit<State, "meta">;

На интервью не обязательно писать этот helper сразу. Достаточно сказать, что с union-типами есть нюанс и иногда нужен дистрибутивный подход.

Во frontend-разработке Omit чаще всего нужен не ради красивого типа, а ради ясного контракта между слоями.

type Product = {
  id: string;
  title: string;
  price: number;
  createdAt: string;
  updatedAt: string;
};

type ProductFormValues = Omit<Product, "id" | "createdAt" | "updatedAt">;

function ProductForm(props: {
  initialValues: ProductFormValues;
  onSubmit: (values: ProductFormValues) => void;
}) {
  return null;
}

Здесь форма не должна знать про серверные поля. Это снижает риск случайно отправить id при создании товара или смешать данные формы с данными, которые назначает backend. Но перед отправкой все равно собирайте payload из values, а не спредьте в запрос исходный Product из state.

Хороший короткий ответ может звучать так:

Omit в TypeScript это utility type, который строит новый тип из существующего и исключает указанные ключи. Например, Omit<User, "password"> даст тип пользователя без password. Я использую его для props, DTO и form values, но помню, что он работает только на уровне типов. Если нужно реально убрать поле из объекта, нужно явно преобразовать данные.

Такая формулировка закрывает определение, пример и главный риск. Если вас спросят глубже, можно добавить про Pick, Exclude, нестрогие ключи и union-типы.