תיעוד TypeScript עם דוגמאות להרצה: Omit

Q: מה Omit עושה ב-TypeScript?

Omit בונה טיפוס אובייקט חדש עם כל המאפיינים של T חוץ מאלה שהמפתחות שלהם נמצאים ב-K. Omit הוא User בלי password. הוא משנה רק את הטיפוס; הוא לא מסיר שום דבר מאובייקט בזמן ריצה.

Q: איך משמיטים כמה מאפיינים ב-TypeScript?

מעבירים איחוד של מפתחות כארגומנט השני: Omit . כל מפתח באיחוד מוסר.

Q: מה ההבדל בין Omit ל-Exclude?

Omit מסיר מאפיינים מטיפוס אובייקט: Omit הוא { b: 2 }. Exclude מסיר איברים מטיפוס איחוד: Exclude הוא "b". Omit ממומש בעזרת Exclude: Pick >.

Q: למה Omit לא נותן שגיאה על מפתח שלא קיים?

פרמטר המפתח שלו מוגבל ל-keyof any (כל מחרוזת, מספר או symbol), ולא ל-keyof T, ולכן שגיאת הקלדה כמו Omit עוברת קומפילציה ולא מסירה כלום. הגדירו type StrictOmit = Omit כדי לקבל שגיאה על מפתחות לא מוכרים.

Q: איך מסירים מאפיין מאובייקט בזמן ריצה ב-TypeScript?

השתמשו ב-destructuring עם איבר rest: const { password, ...rest } = user;. TypeScript נותן ל-rest את טיפוס האובייקט בלי password, אותה צורה כמו Omit , והמאפיין באמת לא קיים באובייקט החדש.

Omit<T, K> הוא utility type מובנה שיוצר טיפוס אובייקט עם כל המאפיינים של T חוץ מהמפתחות שמפורטים ב-K. השימוש הקלאסי: טיפוס User שיש לו password, וגרסה ציבורית שאין לה.

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 נשאר מסונכרן עם User: הוסיפו שדה ל-User והוא יופיע גם ב-PublicUser, בזמן ש-password נשאר בחוץ. Omit עובד על טיפוסים בלבד; ה-destructuring ב-toPublic הוא מה שמסיר את המאפיין מהאובייקט עצמו.

השמטת כמה מפתחות

הארגומנט השני הוא איחוד, אז כתבו כמה מפתחות שצריך עם |:

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

"הטיפוס בלי השדות שהשרת מייצר" הוא ה-Omit הנפוץ ביותר בקוד אמיתי: טיפוס מודל אחד, ו-Omit גוזר ממנו את צורת הקלט לטפסי יצירה ולבקשות API.

איך Omit מוגדר

Omit בנוי משני utility types אחרים:

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

קראו אותו מבפנים החוצה: keyof T הוא האיחוד של כל המפתחות, Exclude<keyof T, K> מסיר מהאיחוד את אלה שלא רוצים, ו-Pick שומר את המפתחות שנשארו. כך ש-Omit<User, "password"> הוא Pick<User, "id" | "name" | "email">. מכיוון ש-Pick ממפה על המפתחות של T, המאפיינים שנשארו שומרים על המגדירים readonly ו-?.

שימו לב להגבלה: K extends keyof any, ולא K extends keyof T. הפרט הזה הוא הנושא של הקטע הבא.

Omit לא בודק שהמפתח קיים

keyof any הוא string | number | symbol, ולכן Omit מקבל כל מפתח שהוא, כולל מפתח שאין ל-T. שגיאת הקלדה עוברת קומפילציה ולא מסירה כלום:

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

אין שגיאה בשום מקום, והסיסמה יוצאת ב-JSON. ההגבלה הרופפת נבחרה בכוונה כש-Omit נוסף ב-TypeScript 3.5. הסיבות של הצוות: בקוד גנרי המפתחות המושמטים לרוב לא מגיעים מ-T (פונקציה שממזגת שני אובייקטים יכולה לתת לארגומנט ה-rest שלה את הטיפוס Omit<T1, keyof T2>), גם Exclude לא מגביל את הפרמטר השני שלו, וגרסה מוגבלת הייתה שוברת הרבה מטיפוסי ה-Omit שפרויקטים כבר כתבו בעצמם. לקוד יומיומי, גרסה קפדנית יותר תופסת את שגיאת ההקלדה:

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

השגיאה הראשונה היא החשובה: המפתח נבדק מול keyof User. השנייה נובעת ממנה, כי שום דבר לא הושמט ו-PublicUser עדיין דורש password. תקנו את האיות ל-"password" והקוד יעבור קומפילציה. בסיסי קוד רבים מגדירים אותו פעם אחת בקובץ טיפוסים משותף ומשתמשים בו במקום ב-Omit.

דריסת טיפוס של מאפיין

interface לא יכול להרחיב interface אחר ולשנות מאפיין לטיפוס לא תואם: interface ApiUser extends User { id: string } נכשל עם error TS2430: Interface 'ApiUser' incorrectly extends interface 'User'. השמיטו קודם את המאפיין, ואז הצהירו עליו שוב:

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

עם type alias אותו דבר נעשה בחיתוך: type ApiUser = Omit<User, "id"> & { id: string }. בלי ה-Omit, החיתוך User & { id: string } היה נותן ל-id את הטיפוס number & string, שהוא never.

Omit על טיפוסי איחוד

Omit אינו דיסטריבוטיבי. על איחוד הוא מתחיל מ-keyof של האיחוד כולו, שמכיל רק את המפתחות שמשותפים לכל האיברים, ולכן המאפיינים הייחודיים של כל איבר נעלמים:

// 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 הפך ל-{ kind: "circle" | "square" }. כדי להשמיט מכל איבר בנפרד, הפעילו את Omit בתוך טיפוס מותנה דיסטריבוטיבי:

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 תמיד מתקיים; הוא שם רק כדי לגרום לטיפוס המותנה להתפלג על האיחוד. דף הטיפוסים המותנים מסביר למה זה עובד. השתמשו ב-DistributiveOmit בכל פעם שהטיפוס שממנו משמיטים הוא discriminated union.

השמטת מאפיין מקונן

Omit מסתכל רק על המפתחות ברמה העליונה, ולכן Omit<Settings, "editor.wordWrap"> לא מסיר כלום (וכמו שראינו למעלה, גם לא מתלונן). כדי להוריד מאפיין רמה אחת פנימה, השמיטו את ההורה והוסיפו אותו בחזרה עם 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"] הוא indexed access type: הוא נותן שם לטיפוס האובייקט המקונן כדי ש-Omit יוכל לעבוד עליו.

הסרת מאפיינים בזמן ריצה

Omit משנה רק את הטיפוס. כדי לקבל אובייקט בלי המאפיינים, הוציאו אותם ב-destructuring, או כתבו פונקציית עזר גנרית קטנה שטיפוס ההחזרה שלה הוא 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 ...

פונקציית העזר מגבילה את K ל-keyof T, ולכן מפתח עם שגיאת כתיב הוא שגיאה במקום הקריאה. ההעתקה רדודה: אובייקטים מקוננים משותפים עם המקור.

Omit מול Pick מול Exclude

	עובד על	שומר	דוגמה	תוצאה
`Omit<T, K>`	טיפוסי אובייקט	כל מאפיין חוץ מ-`K`	`Omit<User, "password">`	`{ id; name; email }`
`Pick<T, K>`	טיפוסי אובייקט	רק את המאפיינים ב-`K`	`Pick<User, "id" \| "name">`	`{ id; name }`
`Exclude<U, M>`	טיפוסי איחוד	איברי איחוד שלא ניתנים לשיוך ל-`M`	`Exclude<"a" \| "b" \| "c", "a">`	`"b" \| "c"`

בחרו בין Omit ל-Pick לפי מה שצריך לקרות כשטיפוס המקור גדל. Omit כולל מאפיינים חדשים אוטומטית, וזה מתאים ל"הכול חוץ מהסוד". Pick אף פעם לא כולל אותם, וזה מתאים ל"בדיוק השדות האלה" ובטוח יותר לכל דבר שיוצא מהשרת שלכם. Pick בודק את המפתחות שלו מול keyof T; Omit לא.

שאלות נפוצות

מה Omit עושה ב-TypeScript?

Omit<T, K> בונה טיפוס אובייקט חדש עם כל המאפיינים של T חוץ מאלה שהמפתחות שלהם נמצאים ב-K. Omit<User, "password"> הוא User בלי password. הוא משנה רק את הטיפוס; הוא לא מסיר שום דבר מאובייקט בזמן ריצה.

איך משמיטים כמה מאפיינים ב-TypeScript?

מעבירים איחוד של מפתחות כארגומנט השני: Omit<User, "password" | "createdAt" | "updatedAt">. כל מפתח באיחוד מוסר.

מה ההבדל בין Omit ל-Exclude?

Omit מסיר מאפיינים מטיפוס אובייקט: Omit<{ a: 1; b: 2 }, "a"> הוא { b: 2 }. Exclude מסיר איברים מטיפוס איחוד: Exclude<"a" | "b", "a"> הוא "b". Omit ממומש בעזרת Exclude: Pick<T, Exclude<keyof T, K>>.

למה Omit לא נותן שגיאה על מפתח שלא קיים?

פרמטר המפתח שלו מוגבל ל-keyof any (כל מחרוזת, מספר או symbol), ולא ל-keyof T, ולכן שגיאת הקלדה כמו Omit<User, "pasword"> עוברת קומפילציה ולא מסירה כלום. הגדירו type StrictOmit<T, K extends keyof T> = Omit<T, K> כדי לקבל שגיאה על מפתחות לא מוכרים.

איך מסירים מאפיין מאובייקט בזמן ריצה ב-TypeScript?

השתמשו ב-destructuring עם איבר rest: const { password, ...rest } = user;. TypeScript נותן ל-rest את טיפוס האובייקט בלי password, אותה צורה כמו Omit<User, "password">, והמאפיין באמת לא קיים באובייקט החדש.

מושגים קשורים