Key remapping with as clause in Typescript - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of key remapping with as clause in mapped types

What is the type of Result after applying the key remapping with as clause in this code?

Typescript

type Original = { a: number; b: string; c: boolean };
type Result = {
  [K in keyof Original as `new_${string & K}`]: Original[K]
};

A { new_a: number; new_b: string; new_c: boolean }

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

C { new_a: string; new_b: string; new_c: string }

D { new_a: number; b: string; c: boolean }

💡 Hint

The as clause renames keys by prefixing them with 'new_'.

The mapped type remaps each key K to a new key `new_${K}` while keeping the original value types.

❓ Predict Output

intermediate

Resulting keys after conditional key remapping

Given this mapped type with conditional key remapping, what keys does Filtered have?

Typescript

type Data = { id: number; name: string; active: boolean };
type Filtered = {
  [K in keyof Data as K extends 'id' | 'active' ? K : never]: Data[K]
};

A {}

B { name: string }

C { id: number; name: string; active: boolean }

D { id: number; active: boolean }

💡 Hint

Keys not matching the condition become never and are removed.

Keys id and active remain, name is removed by remapping to never.

🔧 Debug

advanced

Identify the error in key remapping with invalid key type

What error does this TypeScript code produce?

Typescript

type T = { a: number };
type R = { [K in keyof T as number]: T[K] };

A Type 'number' cannot be used as a key type in mapped types

B No error, type R is { number: number }

C SyntaxError: Unexpected token 'as'

D Type 'string' is expected but 'number' found

💡 Hint

Mapped type keys must be string, number, or symbol literals or unions.

Using a plain 'number' type as a key remapping is invalid because keys must be literal types or unions of literals.

📝 Syntax

advanced

Correct syntax for key remapping with as clause

Which option shows the correct syntax for remapping keys in a mapped type using the as clause?

Typescript

type Original = { x: number; y: string };
type Mapped = { /* fill here */ };

A [K as `new_${K}` in keyof Original]: Original[K]

B [K in keyof Original as `new_${K}`]: Original[K]

C [K in keyof Original] as `new_${K}`: Original[K]

D [K in keyof Original]: Original[K] as `new_${K}`

💡 Hint

The as clause goes immediately after the key variable in the brackets.

The correct syntax is [K in keyof T as NewKey]: Value where as remaps the key.

🚀 Application

expert

Create a mapped type that renames keys to uppercase

Which option correctly defines a mapped type UppercaseKeys that takes an object type T and produces a new type with all keys converted to uppercase strings?

Typescript

type UppercaseKeys<T> = { /* fill here */ };

A { [K in keyof T as K.toUpperCase()]: T[K] }

B { [K in keyof T as string.toUpperCase(K)]: T[K] }

C { [K in keyof T as Uppercase<string & K>]: T[K] }

D { [K in keyof T as Uppercase<K>]: T[K] }

💡 Hint

Use the built-in Uppercase utility type with a string intersection.

Keys must be cast to string & K before applying Uppercase to ensure correct type inference.