Removing modifiers with minus in Typescript - Mini Project: Build & Apply

Excluding Keys with Mapped Type Remapping in TypeScript

📖 Scenario: Imagine you have a TypeScript type representing a user profile with several properties. Sometimes, you want to create a new type that is like the original but without some properties, for example, removing the email and phone contact details.

🎯 Goal: You will create a type called UserProfile with some properties. Then, you will create a new type called ContactlessUser that removes the email and phone properties from UserProfile using key remapping in a mapped type.

📋 What You'll Learn

Create a type UserProfile with properties: name, age, email, and phone.

Create a type ContactlessUser that removes email and phone from UserProfile using mapped type key remapping.

Create a variable user of type ContactlessUser with name and age properties.

Print the user variable to the console.

💡 Why This Matters

🌍 Real World

Removing properties from types is useful when you want to create variations of data models without repeating code, such as hiding sensitive information before sending data to the client.

💼 Career

Understanding how to manipulate types with modifiers is important for writing clean, maintainable TypeScript code in professional web development and software engineering.

1

Create the UserProfile type

Create a type called UserProfile with these exact properties and types: name: string, age: number, email: string, and phone: string.

Typescript

# Your code here
type UserProfile = {
    // define properties
}

Hint

Use type UserProfile = { name: string; age: number; email: string; phone: string; } to define the type.

2

Create ContactlessUser type removing email and phone

Create a type called ContactlessUser that uses a mapped type over keyof UserProfile but removes the keys "email" and "phone" using key remapping. The resulting type should only have name and age.

Typescript

type UserProfile = {
    name: string;
    age: number;
    email: string;
    phone: string;
};

# Your code here
type ContactlessUser = {
    // remove email and phone keys
};

Hint

Use [K in keyof UserProfile as K extends "email" | "phone" ? never : K]: UserProfile[K] to remove keys.

3

Create a variable user of type ContactlessUser

Create a variable called user of type ContactlessUser and assign it an object with name set to "Alice" and age set to 30.

Typescript

type UserProfile = {
    name: string;
    age: number;
    email: string;
    phone: string;
};

type ContactlessUser = {
    [K in keyof UserProfile as K extends "email" | "phone" ? never : K]: UserProfile[K];
};

# Your code here
const user: ContactlessUser = {
    // add name and age
};

Hint

Assign { name: "Alice", age: 30 } to user.

4

Print the user variable

Write a console.log statement to print the user variable to the console.

Typescript

type UserProfile = {
    name: string;
    age: number;
    email: string;
    phone: string;
};

type ContactlessUser = {
    [K in keyof UserProfile as K extends "email" | "phone" ? never : K]: UserProfile[K];
};

const user: ContactlessUser = {
    name: "Alice",
    age: 30
};

# Your code here
console.log(user);

Hint

Use console.log(user); to print the object.

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