Partial type in Typescript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the Partial<T> type do in TypeScript?

Partial<T> makes all properties of type T optional. This means you can create objects with some or none of the properties defined in T.

intermediate

How do you use Partial<T> to update an object partially?

<p>You can pass an object with only the properties you want to update, and TypeScript will allow it because <code>Partial&lt;T&gt;</code> makes all properties optional.</p><p>Example: <code>function updateUser(user: User, updates: Partial&lt;User&gt;) { return {...user, ...updates}; }</code></p>

intermediate

Can Partial<T> be used with nested objects to make nested properties optional?

No, Partial<T> only makes the top-level properties optional. Nested objects inside T remain unchanged and their properties are still required unless you use a deep partial utility.

advanced

Write the TypeScript definition of Partial<T>.

type Partial<T> = { [P in keyof T]?: T[P]; };

This means for each property P in T, make it optional with ?.

beginner

Why is Partial<T> useful in real-world programming?

It helps when you want to update or create objects without specifying every property. For example, when updating user settings, you only provide the changed fields, making code cleaner and safer.

What does Partial<T> do to the properties of type T?

A Makes all properties optional

B Makes all properties required

C Removes all properties

D Makes all properties readonly

Partial<T> makes all properties optional, allowing objects to have any subset of T's properties.

Which of these is a correct use of Partial<T>?

A function update(obj: Readonly<User>) { ... }

B function update(obj: Required<User>) { ... }

C function update(obj: Partial<User>) { ... }

D function update(obj: Pick<User, 'name'>) { ... }

Using Partial<User> allows passing objects with some or no properties of User.

Does Partial<T> make nested object properties optional by default?

A No, only top-level properties become optional

B Only properties of type string become optional

C Yes, all nested properties become optional

D It depends on the TypeScript version

Partial<T> only affects the top-level properties. Nested properties remain unchanged.

What is the correct TypeScript syntax for Partial<T>?

A type Partial<T> = { [P in keyof T]: T[P]; };

B type Partial<T> = { [P in keyof T]?: T[P]; };

C type Partial<T> = { [P in keyof T]-?: T[P]; };

D type Partial<T> = { [P in keyof T]+?: T[P]; };

The ? makes each property optional in the mapped type.

Why might you choose Partial<T> over manually making properties optional?

A It converts properties to strings

B It makes properties readonly

C It deletes properties from the type

D It automatically makes all properties optional without rewriting the type

Partial<T> saves time and reduces errors by automatically making all properties optional.

Explain what the Partial<T> type does and give an example of when you would use it.

Think about updating objects with only some fields changed.

Describe the difference between Partial<T> and a deep partial type regarding nested objects.

Consider how nested objects behave with Partial.

Practice

1.

What does the Partial utility type do in TypeScript?

easy

A. Changes all properties to readonly

B. Makes all properties of a type required

C. Removes all properties from a type

D. Makes all properties of a type optional

Solution

1. Step 1: Understand the purpose of Partial

   The Partial type is designed to take an existing type and make all its properties optional.

2. Step 2: Compare with other utility types

   Unlike Required which makes all properties mandatory, Partial does the opposite by making them optional.

3. Final Answer:

   Makes all properties of a type optional -> Option D

4. Quick Check:

   Partial = optional properties [OK]

Hint: Partial makes properties optional, not required or readonly [OK]

Common Mistakes:

• Confusing Partial with Required
• Thinking Partial removes properties
• Assuming Partial makes properties readonly

2.

Which of the following is the correct syntax to create a partial type of User?

interface User { name: string; age: number; }

easy

A. type PartialUser = Partial<User>;

B. type PartialUser = User.Partial;

C. type PartialUser = Partial<User> = {};

D. type PartialUser = Partial<User> {};

Solution

1. Step 1: Recall correct Partial syntax

   The correct way to create a partial type is using Partial<Type> syntax.

2. Step 2: Check each option

   type PartialUser = Partial<User>; uses correct syntax. Options A, B, and D have invalid or incorrect TypeScript syntax.

3. Final Answer:

   type PartialUser = Partial<User>; -> Option A

4. Quick Check:

   Partial syntax = Partial<Type> [OK]

Hint: Use Partial<Type> to create partial types [OK]

Common Mistakes:

• Using dot notation instead of generic syntax
• Adding extra equals or braces incorrectly
• Confusing Partial with object literals

3.

What is the output of this TypeScript code?

interface Product { id: number; name: string; price: number; }
const updateProduct: Partial<Product> = { price: 99 };
console.log(updateProduct);

medium

A. { id: undefined, name: undefined, price: 99 }

B. { price: 99 }

C. Error: Missing properties id and name

D. {}

Solution

1. Step 1: Understand Partial effect on properties

   Partial makes all properties optional, so you can provide only some properties.

2. Step 2: Check the object assigned

   The object has only price: 99. This is valid and prints exactly that.

3. Final Answer:

   { price: 99 } -> Option B

4. Quick Check:

   Partial allows partial objects [OK]

Hint: Partial lets you omit properties safely [OK]

Common Mistakes:

• Expecting all properties to appear with undefined
• Thinking missing properties cause errors
• Assuming Partial creates empty objects

4.

Identify the error in this code snippet:

interface Settings { theme: string; fontSize: number; }
const newSettings: Partial<Settings> = { theme: 'dark' };
newSettings.fontSize.toFixed(2);

medium

A. Error: toFixed is not a function

B. No error, code runs fine

C. Error: fontSize might be undefined

D. Error: theme property missing

Solution

1. Step 1: Analyze Partial type effect

   Partial makes all properties optional, so fontSize may be undefined.

2. Step 2: Check method call on possibly undefined

   Calling toFixed on possibly undefined fontSize causes a runtime error.

3. Final Answer:

   Error: fontSize might be undefined -> Option C

4. Quick Check:

   Partial properties can be undefined [OK]

Hint: Check for undefined before using Partial properties [OK]

Common Mistakes:

• Ignoring optional property undefined possibility
• Assuming all properties exist
• Confusing method errors with type errors

5.

You have this interface and partial update function:

interface Profile { username: string; email: string; age: number; }
function updateProfile(profile: Profile, updates: Partial<Profile>): Profile {
  return { ...profile, ...updates };
}

What is the result of calling updateProfile({ username: 'alice', email: '[e-mail]', age: 30 }, { email: '[e-mail]' })?

hard

A. { username: 'alice', email: '[e-mail]', age: 30 }

B. { username: 'alice', email: '[e-mail]', age: 30 }

C. Error: Cannot spread Partial type

D. { email: '[e-mail]' }

Solution

1. Step 1: Understand spread with Partial

   The function merges the original profile with updates, overwriting provided fields.

2. Step 2: Apply the update

   The email field is replaced with the new value, others remain unchanged.

3. Final Answer:

   { username: 'alice', email: '[e-mail]', age: 30 } -> Option A

4. Quick Check:

   Spread merges updates over original [OK]

Hint: Spread merges partial updates over full object [OK]

Common Mistakes:

• Thinking Partial cannot be spread
• Expecting original email to remain
• Returning only updates without original fields