Why Removing modifiers with minus in Typescript? - Purpose & Use Cases

The Big Idea

What if you could remove parts of your types with just Omit<Type, 'key'> and save hours of tedious work?

The Scenario

Imagine you have a big list of settings for a user profile, and you want to create a new list that is just like the original but without some specific settings. Doing this by hand means copying each setting except the ones you don't want.

The Problem

Manually copying and removing each unwanted setting is slow and easy to mess up. You might forget one, or accidentally remove the wrong one. It also makes your code long and hard to read.

The Solution

Using the Omit utility lets you quickly and clearly remove specific parts from a type or object. This means your code stays short, clean, and less error-prone.

Before vs After

✗ Before

type UserSettings = { theme: string; notifications: boolean; location: string; };
type NewSettings = { theme: string; location: string; }; // manually removed notifications

✓ After

type UserSettings = { theme: string; notifications: boolean; location: string; };
type NewSettings = Omit<UserSettings, 'notifications'>; // removed notifications with Omit

What It Enables

This lets you easily create new types or objects by removing unwanted parts, making your code more flexible and easier to maintain.

Real Life Example

When building a form, you might want to reuse a user data type but exclude sensitive fields like passwords before sending data to the frontend.

Key Takeaways

Manually removing parts is slow and error-prone.

Omit lets you remove parts quickly and clearly.

This makes your code cleaner and easier to manage.

Practice

1.

What does the minus sign - do in TypeScript mapped types when used with modifiers like readonly or ??

easy

A. It renames the properties by adding a prefix.

B. It removes the specified modifier from the properties.

C. It duplicates the properties with the modifier.

D. It adds the specified modifier to the properties.

Solution

1. Step 1: Understand mapped types modifiers

   In TypeScript, modifiers like readonly and ? control property mutability and optionality.

2. Step 2: Role of minus sign in mapped types

   Using - before a modifier removes that modifier from the properties in the new type.

3. Final Answer:

   It removes the specified modifier from the properties. -> Option B

4. Quick Check:

   Minus sign removes modifiers [OK]

Hint: Minus sign removes modifiers like readonly or optional [OK]

Common Mistakes:

• Thinking minus adds modifiers instead of removing
• Confusing minus with negation in values
• Assuming minus duplicates properties

2.

Which of the following is the correct syntax to remove the readonly modifier from all properties of type T in a mapped type?

type Mutable<T> = {

  [P in keyof T]: T[P]

}

easy

A. type Mutable<T> = { -readonly [P in keyof T]: T[P] }

B. type Mutable<T> = { readonly- [P in keyof T]: T[P] }

C. type Mutable<T> = { [P in keyof T]-: T[P] }

D. type Mutable<T> = { [P in keyof T]: -readonly T[P] }

Solution

1. Step 1: Syntax for removing readonly modifier

   In mapped types, -readonly placed before the property name removes the readonly modifier.

2. Step 2: Check each option

   type Mutable<T> = { -readonly [P in keyof T]: T[P] } correctly uses -readonly [P in keyof T]. Others misuse syntax or place minus incorrectly.

3. Final Answer:

   type Mutable<T> = { -readonly [P in keyof T]: T[P] } -> Option A

4. Quick Check:

   Minus before readonly removes it [OK]

Hint: Use -readonly before property in mapped type [OK]

Common Mistakes:

• Placing minus after readonly
• Putting minus inside property type
• Using minus without readonly keyword

3.

Given the following code, what is the type of Result?

type Original = { readonly a: number; b?: string; c: boolean };

type Result = { -readonly [K in keyof Original]-?: Original[K] };

medium

A. { readonly a: number; b?: string; c: boolean }

B. { readonly a: number; b: string; c: boolean }

C. { a: number; b?: string; c: boolean }

D. { a: number; b: string; c: boolean }

Solution

1. Step 1: Analyze modifiers removed

   The -readonly removes readonly from all properties. The -? removes optional modifier, making all properties required.

2. Step 2: Apply changes to Original type

   Property a loses readonly, b loses optional, so b becomes required string, c stays boolean required.

3. Final Answer:

   { a: number; b: string; c: boolean } -> Option D

4. Quick Check:

   Minus removes readonly and optional [OK]

Hint: Minus removes modifiers, so readonly and ? are gone [OK]

Common Mistakes:

• Forgetting that -? removes optional
• Assuming readonly stays
• Thinking optional remains

4.

Identify the error in this mapped type that tries to remove the ? optional modifier:

type RequiredProps<T> = { [P in keyof T]-?: T[P] }

Which statement is true?

medium

A. Minus sign cannot be used to remove optional modifiers.

B. Minus sign should be before the property name like -? [P in keyof T].

C. The syntax is correct; it removes the optional modifier.

D. The minus sign must be after the property name like [P in keyof T]? -.

Solution

1. Step 1: Check syntax for removing optional modifier

   In mapped types, placing -? immediately after the property name removes the optional modifier.

2. Step 2: Verify given code

   The code uses [P in keyof T]-?: T[P], which is correct syntax to remove optional.

3. Final Answer:

   The syntax is correct; it removes the optional modifier. -> Option C

4. Quick Check:

   Minus after property removes optional [OK]

Hint: Minus ? after property removes optional modifier [OK]

Common Mistakes:

• Placing minus before property name for optional
• Thinking minus can't remove optional
• Misplacing minus sign

5.

You have a type with some properties readonly and some optional:

type Data = { readonly id: number; name?: string; active: boolean };

Write a mapped type CleanData that removes both readonly and ? modifiers from all properties.

Which of these is correct?

hard

A. type CleanData = { -readonly [P in keyof Data]-?: Data[P] }

B. type CleanData = { [P in keyof Data]-readonly-?: Data[P] }

C. type CleanData = { [P in keyof Data]-readonly -?: Data[P] }

D. type CleanData = { -readonly -? [P in keyof Data]: Data[P] }

Solution

1. Step 1: Remove readonly modifier

   Use -readonly before the property name to remove readonly.

2. Step 2: Remove optional modifier

   Use -? immediately after the property name to remove optional.

3. Step 3: Combine both in mapped type

   Correct syntax is { -readonly [P in keyof Data]-?: Data[P] }.

4. Final Answer:

   type CleanData = { -readonly [P in keyof Data]-?: Data[P] } -> Option A

5. Quick Check:

   Minus readonly before and minus ? after property [OK]

Hint: Minus readonly before, minus ? after property name [OK]

Common Mistakes:

• Placing minus signs incorrectly
• Trying to put minus signs inside brackets
• Using spaces that break syntax