Omit di TypeScript: Menghapus Property dari Tipe (Contoh)

Omit<T, K> adalah utility type bawaan yang membuat object type berisi semua property T kecuali key yang tercantum di K. Contoh klasiknya: tipe User yang punya password, dan versi publiknya yang tidak punya.

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 selalu sinkron dengan User: tambahkan field ke User dan field itu muncul juga di PublicUser, sementara password tetap tidak ikut. Omit hanya bekerja pada tipe; destructuring di toPublic itulah yang menghapus property dari object yang sebenarnya.

Meng-omit Beberapa Key

Argumen kedua adalah union, jadi daftarkan key sebanyak yang kamu perlukan dengan |:

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'.

"Tipe tanpa field yang dibuat server" adalah pemakaian Omit yang paling umum dalam kode nyata: satu tipe model, lalu Omit menurunkan bentuk input untuk form pembuatan data dan request API.

Bagaimana Omit Didefinisikan

Omit dibangun dari dua utility type lain:

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

Baca dari dalam: keyof T adalah union semua key, Exclude<keyof T, K> menghapus key yang tidak diinginkan dari union itu, dan Pick mempertahankan key yang tersisa. Jadi Omit<User, "password"> adalah Pick<User, "id" | "name" | "email">. Karena Pick melakukan mapping atas key milik T, modifier readonly dan ? pada property yang tersisa tetap dipertahankan.

Perhatikan batasannya: K extends keyof any, bukan K extends keyof T. Detail itulah yang dibahas di bagian berikutnya.

Omit Tidak Mengecek Apakah Key-nya Ada

keyof any adalah string | number | symbol, jadi Omit menerima key apa pun, termasuk key yang tidak dimiliki T. Salah ketik tetap lolos kompilasi dan tidak menghapus apa pun:

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"}

Tidak ada error di mana pun, dan password-nya ikut terkirim di JSON. Batasan yang longgar ini dipilih dengan sengaja saat Omit ditambahkan di TypeScript 3.5. Alasan timnya: di kode generic, key yang di-omit sering tidak berasal dari T (fungsi yang menggabungkan dua object bisa memberi tipe argumen rest-nya sebagai Omit<T1, keyof T2>), Exclude juga tidak membatasi parameter keduanya, dan versi yang dibatasi akan merusak banyak tipe Omit buatan sendiri yang sudah ada di berbagai proyek. Untuk kode sehari-hari, versi yang lebih ketat bisa menangkap salah ketik itu:

// 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'.

Error pertama adalah yang penting: key-nya dicek terhadap keyof User. Error kedua muncul akibat yang pertama, karena tidak ada yang di-omit dan PublicUser masih mewajibkan password. Perbaiki ejaannya menjadi "password" dan kodenya lolos kompilasi. Banyak codebase mendefinisikannya sekali di file tipe bersama dan memakainya sebagai pengganti Omit.

Mengganti Tipe Property

Sebuah interface tidak bisa meng-extend interface lain sambil mengubah property ke tipe yang tidak kompatibel: interface ApiUser extends User { id: string } gagal dengan error TS2430: Interface 'ApiUser' incorrectly extends interface 'User'. Omit property itu dulu, lalu deklarasikan lagi:

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' }

Dengan type alias, hal yang sama ditulis sebagai intersection: type ApiUser = Omit<User, "id"> & { id: string }. Tanpa Omit, intersection User & { id: string } akan memberi id tipe number & string, yaitu never.

Omit pada Tipe Union

Omit tidak bersifat distributif. Pada union, ia mulai dari keyof seluruh union, yang hanya berisi key yang dimiliki semua anggotanya, sehingga property milik masing-masing anggota hilang:

// 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 berubah menjadi { kind: "circle" | "square" }. Untuk meng-omit dari setiap anggota secara terpisah, terapkan Omit di dalam conditional type yang distributif:

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 selalu bernilai true; bagian ini ada hanya supaya conditional type terdistribusi ke setiap anggota union. Halaman conditional types menjelaskan kenapa cara ini berhasil. Pakai DistributiveOmit setiap kali tipe yang kamu omit adalah discriminated union.

Meng-omit Property Bersarang

Omit hanya melihat key di level teratas, jadi Omit<Settings, "editor.wordWrap"> tidak menghapus apa pun (dan, seperti yang ditunjukkan di atas, tidak mengeluh). Untuk membuang property satu level di bawahnya, omit property induknya lalu tambahkan lagi dengan Omit miliknya sendiri:

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"] adalah indexed access type: ia menamai object type yang bersarang supaya Omit bisa bekerja padanya.

Menghapus Property Saat Runtime

Omit hanya mengubah tipe. Untuk menghasilkan object tanpa property tertentu, buang property itu lewat destructuring, atau tulis helper generic kecil yang tipe kembaliannya 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 ...

Helper itu membatasi K ke keyof T, jadi key yang salah eja menjadi error di tempat pemanggilan. Salinannya dangkal: object bersarang tetap dipakai bersama dengan aslinya.

Omit vs Pick vs Exclude

Pilih antara Omit dan Pick berdasarkan apa yang seharusnya terjadi saat tipe sumbernya bertambah. Omit otomatis menyertakan property baru, cocok untuk "semuanya kecuali yang rahasia". Pick tidak pernah menyertakannya, cocok untuk "tepat field-field ini" dan lebih aman untuk apa pun yang keluar dari server-mu. Pick mengecek key-nya terhadap keyof T; Omit tidak.