Dokumentacja TypeScript z przykładami: Omit

Q: Co robi Omit w TypeScript?

Omit buduje nowy typ obiektowy ze wszystkimi właściwościami T poza tymi, których klucze są w K. Omit to User bez password. Zmienia tylko typ; niczego nie usuwa z obiektu w czasie działania.

Q: Jak pominąć kilka właściwości w TypeScript?

Przekaż unię kluczy jako drugi argument: Omit . Każdy klucz z unii zostaje usunięty.

Q: Czym różni się Omit od Exclude?

Omit usuwa właściwości z typu obiektowego: Omit to { b: 2 }. Exclude usuwa elementy z unii: Exclude to "b". Omit jest zaimplementowany przez Exclude: Pick >.

Q: Dlaczego Omit nie zgłasza błędu dla klucza, który nie istnieje?

Jego parametr kluczy jest ograniczony do keyof any (dowolny string, liczba lub symbol), a nie do keyof T, więc literówka taka jak Omit się kompiluje i niczego nie usuwa. Zdefiniuj type StrictOmit = Omit , żeby dostać błąd dla nieznanych kluczy.

Q: Jak usunąć właściwość z obiektu w czasie działania w TypeScript?

Użyj destrukturyzacji z elementem rest: const { password, ...rest } = user;. TypeScript nadaje rest typ obiektu bez password, ten sam kształt co Omit , a właściwości naprawdę nie ma w nowym obiekcie.

Omit<T, K> to wbudowany typ narzędziowy, który tworzy typ obiektowy ze wszystkimi właściwościami T poza kluczami wymienionymi w K. Klasyczne zastosowanie: typ User z polem password i jego publiczna wersja bez tego pola.

interface User {
  id: number;
  name: string;
  email: string;
  password: string;
}

type PublicUser = Omit<User, "password">;
// { id: number; name: string; email: string }

function toPublic(user: User): PublicUser {
  const { password, ...rest } = user; // really remove it from the object
  return rest;
}

const ada: User = { id: 1, name: "Ada", email: "ada@example.com", password: "s3cret" };
console.log(toPublic(ada)); // { id: 1, name: 'Ada', email: 'ada@example.com' }

PublicUser pozostaje zsynchronizowany z User: dodaj pole do User, a pojawi się też w PublicUser, podczas gdy password zostaje poza nim. Omit działa tylko na typach; to destrukturyzacja w toPublic usuwa właściwość z rzeczywistego obiektu.

Pomijanie kilku kluczy

Drugi argument to unia, więc wymień przez | tyle kluczy, ile potrzebujesz:

interface Post {
  id: number;
  title: string;
  body: string;
  createdAt: string;
  updatedAt: string;
}

// What a client sends to create a post: the server fills in the rest
type NewPost = Omit<Post, "id" | "createdAt" | "updatedAt">;

function createPost(input: NewPost, id: number): Post {
  const now = "2024-03-15T10:30:00.000Z";
  return { ...input, id, createdAt: now, updatedAt: now };
}

const post = createPost({ title: "Hello", body: "First post" }, 7);
console.log(post.id, post.title, post.createdAt); // 7 Hello 2024-03-15T10:30:00.000Z
// createPost({ title: "x", body: "y", id: 1 }, 7) would be error TS2353:
// Object literal may only specify known properties, and 'id' does not exist in type 'NewPost'.

"Typ bez pól generowanych przez serwer" to najczęstszy Omit w prawdziwym kodzie: jeden typ modelu, a Omit wyprowadza z niego kształt danych wejściowych dla formularzy tworzenia i żądań API.

Jak zdefiniowany jest Omit

Omit jest zbudowany z dwóch innych typów narzędziowych:

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

Czytaj od środka: keyof T to unia wszystkich kluczy, Exclude<keyof T, K> usuwa z niej niechciane klucze, a Pick zachowuje pozostałe. Tak więc Omit<User, "password"> to Pick<User, "id" | "name" | "email">. Ponieważ Pick mapuje po kluczach T, modyfikatory readonly i ? na pozostałych właściwościach zostają zachowane.

Zwróć uwagę na ograniczenie: K extends keyof any, a nie K extends keyof T. Ten szczegół jest tematem następnej sekcji.

Omit nie sprawdza, czy klucz istnieje

keyof any to string | number | symbol, więc Omit przyjmuje dowolny klucz, także taki, którego T nie ma. Literówka się kompiluje i niczego nie usuwa:

interface User {
  id: number;
  name: string;
  password: string;
}

type PublicUser = Omit<User, "pasword">; // typo: nothing is omitted

function toPublic(user: User): PublicUser {
  return user; // compiles, because PublicUser still has password
}

console.log(JSON.stringify(toPublic({ id: 1, name: "Ada", password: "s3cret" })));
// {"id":1,"name":"Ada","password":"s3cret"}

Nigdzie żadnego błędu, a hasło wychodzi w JSON-ie. Luźne ograniczenie wybrano celowo, gdy Omit dodano w TypeScript 3.5. Powody zespołu: w kodzie generycznym pomijane klucze często nie pochodzą z T (funkcja łącząca dwa obiekty może otypować swój argument rest jako Omit<T1, keyof T2>), Exclude też nie ogranicza swojego drugiego parametru, a wersja z ograniczeniem zepsułaby wiele ręcznie napisanych typów Omit, które projekty już miały. W codziennym kodzie ściślejsza wersja wyłapuje literówkę:

// This does not compile: StrictOmit only accepts real keys of User
type StrictOmit<T, K extends keyof T> = Omit<T, K>;

interface User {
  id: number;
  name: string;
  password: string;
}

type PublicUser = StrictOmit<User, "pasword">;
const u: PublicUser = { id: 1, name: "Ada" };
console.log(u);

index.ts(10,36): error TS2344: Type '"pasword"' does not satisfy the constraint 'keyof User'.
index.ts(11,7): error TS2741: Property 'password' is missing in type '{ id: number; name: string; }' but required in type 'PublicUser'.

Liczy się pierwszy błąd: klucz jest sprawdzany względem keyof User. Drugi z niego wynika, bo nic nie zostało pominięte i PublicUser nadal wymaga password. Popraw pisownię na "password" i kod się skompiluje. Wiele projektów definiuje go raz we wspólnym pliku typów i używa zamiast Omit.

Nadpisywanie typu właściwości

Interfejs nie może rozszerzyć innego i zmienić właściwości na niezgodny typ: interface ApiUser extends User { id: string } kończy się error TS2430: Interface 'ApiUser' incorrectly extends interface 'User'. Najpierw pomiń właściwość, a potem zadeklaruj ją ponownie:

interface User {
  id: number;
  name: string;
  createdAt: Date;
}

// The JSON version: id is a string and dates are ISO strings
interface ApiUser extends Omit<User, "id" | "createdAt"> {
  id: string;
  createdAt: string;
}

function toApi(user: User): ApiUser {
  return { ...user, id: String(user.id), createdAt: user.createdAt.toISOString() };
}

const u: User = { id: 7, name: "Ada", createdAt: new Date("2024-03-15T10:30:00Z") };
console.log(toApi(u)); // { id: '7', name: 'Ada', createdAt: '2024-03-15T10:30:00.000Z' }

Z aliasem typu to samo robi przecięcie: type ApiUser = Omit<User, "id"> & { id: string }. Bez Omit przecięcie User & { id: string } dałoby id typ number & string, czyli never.

Omit na uniach

Omit nie jest rozdzielny. Na unii zaczyna od keyof całej unii, które zawiera tylko klucze wspólne dla wszystkich elementów, więc własne właściwości elementów znikają:

// This does not compile: Omit collapsed the union into its shared keys
type Shape =
  | { kind: "circle"; radius: number; id: string }
  | { kind: "square"; size: number; id: string };

type NewShape = Omit<Shape, "id">;

const c: NewShape = { kind: "circle", radius: 2 };
console.log(c);

index.ts(8,39): error TS2353: Object literal may only specify known properties, and 'radius' does not exist in type 'NewShape'.

NewShape stał się { kind: "circle" | "square" }. Aby pominąć klucz w każdym elemencie osobno, zastosuj Omit wewnątrz rozdzielnego typu warunkowego:

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

type Shape =
  | { kind: "circle"; radius: number; id: string }
  | { kind: "square"; size: number; id: string };

type NewShape = DistributiveOmit<Shape, "id">;
// Omit<circle, "id"> | Omit<square, "id">

function area(s: NewShape): number {
  return s.kind === "circle" ? Math.PI * s.radius ** 2 : s.size ** 2; // narrowing works
}

console.log(area({ kind: "square", size: 3 }));            // 9
console.log(area({ kind: "circle", radius: 1 }).toFixed(2)); // 3.14

T extends unknown ? ... : never jest zawsze prawdziwe; jest tam tylko po to, żeby typ warunkowy rozdzielił się na elementy unii. Strona o typach warunkowych wyjaśnia, dlaczego to działa. Używaj DistributiveOmit zawsze, gdy typ, z którego pomijasz, jest unią rozróżnialną.

Pomijanie zagnieżdżonej właściwości

Omit patrzy tylko na klucze najwyższego poziomu, więc Omit<Settings, "editor.wordWrap"> niczego nie usuwa (i, jak pokazano wyżej, nie protestuje). Aby usunąć właściwość poziom niżej, pomiń rodzica i dodaj go z powrotem z jego własnym Omit:

interface Settings {
  theme: string;
  editor: { fontSize: number; tabSize: number; wordWrap: boolean };
}

type SettingsDraft = Omit<Settings, "editor"> & {
  editor: Omit<Settings["editor"], "wordWrap">;
};

const draft: SettingsDraft = { theme: "dark", editor: { fontSize: 14, tabSize: 2 } };
console.log(draft.editor); // { fontSize: 14, tabSize: 2 }
// Adding wordWrap: true to editor would be error TS2353

Settings["editor"] to indexed access type: nazywa zagnieżdżony typ obiektowy, żeby Omit mógł na nim działać.

Usuwanie właściwości w czasie działania

Omit zmienia tylko typ. Aby utworzyć obiekt bez tych właściwości, usuń je destrukturyzacją albo napisz małą funkcję generyczną, której typ zwracany to Omit:

function omit<T extends object, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K> {
  const copy = { ...obj };
  for (const key of keys) delete copy[key];
  return copy;
}

const order = { id: 42, total: 99.5, cardNumber: "4111 1111", cvv: "123" };

const safe = omit(order, "cardNumber", "cvv"); // { id: number; total: number }
console.log(safe);        // { id: 42, total: 99.5 }
console.log(order.cvv);   // 123 (the original is untouched)
// safe.cvv would be error TS2339: Property 'cvv' does not exist on type ...

Funkcja ogranicza K do keyof T, więc błędnie wpisany klucz to błąd w miejscu wywołania. Kopia jest płytka: zagnieżdżone obiekty są współdzielone z oryginałem.

Omit a Pick a Exclude

	Działa na	Zachowuje	Przykład	Wynik
`Omit<T, K>`	typach obiektowych	każdą właściwość poza `K`	`Omit<User, "password">`	`{ id; name; email }`
`Pick<T, K>`	typach obiektowych	tylko właściwości z `K`	`Pick<User, "id" \| "name">`	`{ id; name }`
`Exclude<U, M>`	uniach	elementy unii nieprzypisywalne do `M`	`Exclude<"a" \| "b" \| "c", "a">`	`"b" \| "c"`

Wybieraj między Omit a Pick na podstawie tego, co ma się stać, gdy typ źródłowy się rozrośnie. Omit automatycznie obejmuje nowe właściwości, co pasuje do "wszystko poza sekretem". Pick nigdy ich nie obejmuje, co pasuje do "dokładnie te pola" i jest bezpieczniejsze dla wszystkiego, co opuszcza twój serwer. Pick sprawdza swoje klucze względem keyof T; Omit tego nie robi.

Najczęściej zadawane pytania

Co robi Omit w TypeScript?

Omit<T, K> buduje nowy typ obiektowy ze wszystkimi właściwościami T poza tymi, których klucze są w K. Omit<User, "password"> to User bez password. Zmienia tylko typ; niczego nie usuwa z obiektu w czasie działania.

Jak pominąć kilka właściwości w TypeScript?

Przekaż unię kluczy jako drugi argument: Omit<User, "password" | "createdAt" | "updatedAt">. Każdy klucz z unii zostaje usunięty.

Czym różni się Omit od Exclude?

Omit usuwa właściwości z typu obiektowego: Omit<{ a: 1; b: 2 }, "a"> to { b: 2 }. Exclude usuwa elementy z unii: Exclude<"a" | "b", "a"> to "b". Omit jest zaimplementowany przez Exclude: Pick<T, Exclude<keyof T, K>>.

Dlaczego Omit nie zgłasza błędu dla klucza, który nie istnieje?

Jego parametr kluczy jest ograniczony do keyof any (dowolny string, liczba lub symbol), a nie do keyof T, więc literówka taka jak Omit<User, "pasword"> się kompiluje i niczego nie usuwa. Zdefiniuj type StrictOmit<T, K extends keyof T> = Omit<T, K>, żeby dostać błąd dla nieznanych kluczy.

Jak usunąć właściwość z obiektu w czasie działania w TypeScript?

Użyj destrukturyzacji z elementem rest: const { password, ...rest } = user;. TypeScript nadaje rest typ obiektu bez password, ten sam kształt co Omit<User, "password">, a właściwości naprawdę nie ma w nowym obiekcie.

Powiązane zagadnienia