Omit type in Typescript - Step-by-Step Execution

Concept Flow - Omit type

Start with full type

↓

Choose keys to omit

↓

Remove chosen keys from type

↓

Resulting type without omitted keys

Omit type creates a new type by removing specified keys from an existing type.

Execution Sample

Typescript

type Person = { name: string; age: number; city: string };
type PersonWithoutAge = Omit<Person, 'age'>;

const p: PersonWithoutAge = { name: 'Alice', city: 'Paris' };

This code creates a new type by omitting 'age' from Person, then uses it to declare an object.

Execution Table

Step	Action	Type Before	Keys Omitted	Type After
1	Define Person type	N/A	N/A	{ name: string; age: number; city: string }
2	Apply Omit<Person, 'age'>	{ name: string; age: number; city: string }	'age'	{ name: string; city: string }
3	Declare variable p	{ name: string; city: string }	N/A	p = { name: 'Alice', city: 'Paris' }
4	Try to add omitted key 'age' to p	p type excludes 'age'	'age'	Error: Property 'age' does not exist on type 'PersonWithoutAge'

💡 Omit removes specified keys, so 'age' is not allowed in PersonWithoutAge.

Variable Tracker

Variable	Start	After Omit	Final
p	undefined	{ name: string; city: string }	{ name: 'Alice', city: 'Paris' }

Key Moments - 2 Insights

Why can't I add the 'age' property to the variable p after using Omit?

Because Omit removes the 'age' key from the type, the variable p's type no longer includes 'age' as shown in execution_table step 4.

Does Omit change the original type Person?

No, Omit creates a new type without the specified keys but leaves the original type Person unchanged, as seen in execution_table step 2.

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what keys remain in the type after omitting 'age'?

A 'name' only

B 'name' and 'city'

C 'age' only

D All keys remain

💡 Hint

Check the 'Type After' column in step 2 of the execution_table.

At which step does the variable p get assigned its final value?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look for the step where p is declared and assigned in the execution_table.

If you try to add 'age' back to p, what happens according to the execution_table?

A It works fine

B The 'age' property is ignored

C TypeScript throws an error

D The type Person changes

💡 Hint

See step 4 in the execution_table for what happens when adding omitted keys.

Concept Snapshot

Omit<Type, Keys> creates a new type by removing Keys from Type.
Syntax: type NewType = Omit<OldType, 'key1' | 'key2'>;
Use it to exclude properties you don't want.
Original type stays unchanged.
Trying to use omitted keys causes errors.

Full Transcript

The Omit type in TypeScript helps create a new type by removing certain keys from an existing type. For example, starting with a Person type that has name, age, and city, using Omit<Person, 'age'> creates a new type without the age property. When declaring a variable of this new type, you can only use the remaining keys. Trying to add the omitted key causes a TypeScript error. This process does not change the original type. The execution table shows each step: defining the original type, applying Omit, declaring a variable with the new type, and the error when adding omitted keys. The variable tracker shows how the variable p changes from undefined to the final object without age. Common confusions include why omitted keys can't be added and whether the original type changes. The visual quiz tests understanding of which keys remain, when the variable is assigned, and what happens if omitted keys are added.

Practice

1.

What does the Omit utility type do in TypeScript?

easy

A. Adds new properties to an existing type.

B. Creates a new type by removing specified properties from an existing type.

C. Makes all properties in a type optional.

D. Converts all properties in a type to readonly.

Solution

1. Step 1: Understand the purpose of Omit

   The Omit type is designed to create a new type by excluding certain properties from an existing type.

2. Step 2: Compare with other utility types

   Other utility types like Partial or Readonly modify properties differently, but Omit specifically removes keys.

3. Final Answer:

   Creates a new type by removing specified properties from an existing type. -> Option B

4. Quick Check:

   Omit = Remove properties [OK]

Hint: Omit removes keys from a type to exclude them [OK]

Common Mistakes:

• Confusing Omit with Partial or Pick
• Thinking Omit adds properties
• Assuming Omit makes properties optional

2.

Which of the following is the correct syntax to create a new type PersonWithoutAge by omitting the age property from Person?

type Person = { name: string; age: number; };

easy

A. type PersonWithoutAge = Omit;

B. type PersonWithoutAge = Omit<'age', Person>;

C. type PersonWithoutAge = Omit;

D. type PersonWithoutAge = Omit;

Solution

1. Step 1: Recall Omit syntax

   The correct syntax is Omit, where Keys is a string literal or union of keys to remove.

2. Step 2: Check each option

   type PersonWithoutAge = Omit; uses Omit which is correct. type PersonWithoutAge = Omit<'age', Person>; reverses parameters. type PersonWithoutAge = Omit; misses quotes around 'age'. type PersonWithoutAge = Omit; uses array syntax which is invalid.

3. Final Answer:

   type PersonWithoutAge = Omit; -> Option D

4. Quick Check:

   Omit syntax [OK]

Hint: Omit syntax: Omit with quotes [OK]

Common Mistakes:

• Forgetting quotes around property names
• Swapping type and keys order
• Using array syntax for keys

3.

Given the code below, what is the type of userWithoutPassword?

type User = { id: number; username: string; password: string; };
type UserWithoutPassword = Omit;
const userWithoutPassword: UserWithoutPassword = { id: 1, username: 'alice' };

medium

A. { id: number; username: string; }

B. { username: string; password: string; }

C. { id: number; username: string; password: string; }

D. { id: number; password: string; }

Solution

1. Step 1: Understand Omit effect on User type

   Omit removes the 'password' property, so the new type has only 'id' and 'username'.

2. Step 2: Match the resulting type

   The type of userWithoutPassword matches { id: number; username: string; } exactly.

3. Final Answer:

   { id: number; username: string; } -> Option A

4. Quick Check:

   Omit removes 'password' property [OK]

Hint: Omit removes keys, so missing 'password' here [OK]

Common Mistakes:

• Including omitted property in the result
• Confusing omitted keys with optional keys
• Assuming omitted keys remain in type

4.

Identify the error in the following code snippet:

type Product = { id: number; name: string; price: number; };
type ProductWithoutPrice = Omit;

medium

A. Omit requires an array of keys, not a single key.

B. Omit cannot be used with number properties.

C. Missing quotes around 'price' in Omit type.

D. ProductWithoutPrice should be an interface, not a type.

Solution

1. Step 1: Check Omit syntax

   The second parameter of Omit must be a string literal or union of string literals representing keys, so it must be quoted.

2. Step 2: Identify the error

   In the code, price is unquoted, causing a syntax error.

3. Final Answer:

   Missing quotes around 'price' in Omit type. -> Option C

4. Quick Check:

   Omit keys must be quoted strings [OK]

Hint: Always quote keys in Omit like 'key' [OK]

Common Mistakes:

• Forgetting quotes around keys
• Using number or variable instead of string literal
• Thinking Omit needs arrays for single keys

5.

Given the following types, how can you create a new type EmployeeContact that includes all properties of Employee except salary and department?

type Employee = { id: number; name: string; salary: number; department: string; email: string; };

hard

A. type EmployeeContact = Omit;

B. type EmployeeContact = Omit;

C. type EmployeeContact = Omit;

D. type EmployeeContact = Omit;

Solution

1. Step 1: Understand Omit with multiple keys

   Omit accepts a union of string literals to remove multiple properties at once.

2. Step 2: Check correct syntax for multiple keys

   The correct syntax is Omit using the pipe symbol to combine keys.

3. Final Answer:

   type EmployeeContact = Omit; -> Option A

4. Quick Check:

   Omit with union keys uses 'key1' | 'key2' [OK]

Hint: Use pipe '|' to omit multiple keys in Omit [OK]

Common Mistakes:

• Using array syntax for keys
• Missing quotes around keys
• Passing multiple arguments instead of union