Excess property checking behavior in Typescript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is excess property checking in TypeScript?

Excess property checking is a TypeScript feature that warns you when you provide extra properties in an object literal that are not expected by the target type.

intermediate

Why does TypeScript perform excess property checking only on object literals?

TypeScript checks object literals for extra properties to catch typos or mistakes early. It does not check variables or objects assigned from elsewhere to allow flexibility.

intermediate

How can you avoid excess property checking errors when passing objects with extra properties?

You can assign the object to a variable first, or use type assertions to tell TypeScript to trust your object shape and skip excess property checks.

beginner

What happens if you pass an object literal with an extra property to a function expecting a specific type?

TypeScript will give an error about the extra property because it does excess property checking on object literals to prevent mistakes.

advanced

Can excess property checking be bypassed by using index signatures in TypeScript interfaces?

Yes, if an interface has an index signature like [key: string]: any, excess property checking is relaxed because extra properties are allowed.

When does TypeScript perform excess property checking?

A On all objects, including variables and function returns

B Only on arrays

C Only on object literals assigned directly to variables or parameters

D Only on primitive types

TypeScript performs excess property checking only on object literals directly assigned to variables or passed as parameters.

What error will TypeScript give if you pass an object literal with an unexpected property to a function expecting a specific type?

A Excess property error

B Syntax error

C Runtime error

D No error

TypeScript will report an excess property error to warn about unexpected properties in object literals.

How can you avoid excess property checking errors when you want to pass extra properties?

A Use a number instead of an object

B Use a different programming language

C Remove all properties

D Assign the object to a variable before passing it

Assigning the object to a variable first disables excess property checking on that variable.

What effect does an index signature have on excess property checking?

A It disables excess property checking for extra properties

B It causes more errors

C It only allows numeric keys

D It has no effect

An index signature allows extra properties, so excess property checking is relaxed.

Which of these is a common reason for excess property checking errors?

A Passing a number instead of an object

B A typo in a property name in an object literal

C Using a variable instead of an object literal

D Using a function instead of an object

Typos in property names cause extra properties that TypeScript flags during excess property checking.

Explain what excess property checking is and why TypeScript uses it.

Think about how TypeScript helps catch typos in object properties.

Describe two ways to avoid excess property checking errors when passing objects with extra properties.

Consider how you can tell TypeScript to trust your object shape.

Practice

1. What does excess property checking in TypeScript do when you assign an object literal to a variable typed with an interface?

easy

A. It automatically removes extra properties from the object.

B. It ignores any extra properties without warnings.

C. It warns if the object literal has properties not defined in the interface.

D. It throws a runtime error if extra properties exist.

Solution

1. Step 1: Understand excess property checking purpose

   TypeScript checks object literals assigned to typed variables to catch unexpected properties early.

2. Step 2: Behavior on extra properties

   If the object literal has properties not in the interface, TypeScript warns to prevent bugs.

3. Final Answer:

   It warns if the object literal has properties not defined in the interface. -> Option C

4. Quick Check:

   Excess property checking warns on extra keys [OK]

Hint: Extra keys in object literals cause warnings [OK]

Common Mistakes:

• Thinking extra properties are removed automatically
• Believing excess property checking applies to variables, not literals
• Assuming runtime errors occur due to excess properties

2. Which of the following TypeScript code snippets will cause an excess property checking error?

easy

A. const obj: {name: string} = {name: "Alice", age: 30};

B. const obj = {name: "Alice", age: 30};

C. const obj: {name: string, age?: number} = {name: "Alice"};

D. const obj: {name: string} = {name: "Alice"};

Solution

1. Step 1: Identify object literal with extra property

   const obj: {name: string} = {name: "Alice", age: 30}; assigns an object literal with an extra property 'age' to a type expecting only 'name'.

2. Step 2: Check excess property rules

   TypeScript flags extra properties in object literals when they don't exist in the target type.

3. Final Answer:

   const obj: {name: string} = {name: "Alice", age: 30}; -> Option A

4. Quick Check:

   Extra property 'age' causes error [OK]

Hint: Extra keys in typed object literals cause errors [OK]

Common Mistakes:

• Confusing object literals with variables
• Ignoring optional properties
• Assuming all extra properties are allowed

3. What will be the output of the following TypeScript code?

interface Person { name: string; age: number; }
const p: Person = { name: "Bob", age: 25, city: "NY" };

medium

A. Compilation error due to excess property 'city'.

B. Object p is created with all three properties.

C. Runtime error because 'city' is not in Person.

D. Only 'name' and 'age' are assigned; 'city' is ignored.

Solution

1. Step 1: Check object literal assignment to interface

   The object literal has an extra property 'city' not defined in Person.

2. Step 2: Apply excess property checking rules

   TypeScript raises a compile-time error for extra properties in object literals assigned to typed variables.

3. Final Answer:

   Compilation error due to excess property 'city'. -> Option A

4. Quick Check:

   Extra property in literal causes compile error [OK]

Hint: Extra keys in object literals cause compile errors [OK]

Common Mistakes:

• Thinking extra keys are ignored silently
• Expecting runtime errors instead of compile errors
• Assuming object creation succeeds with extra keys

4. Consider this TypeScript code:

interface Car { make: string; model: string; }
const myCar = { make: "Toyota", model: "Camry", year: 2020 };
const car: Car = myCar;

Why does this code NOT cause an excess property checking error?

medium

A. Because TypeScript ignores extra properties in all assignments.

B. Because excess property checking only applies to object literals, not variables.

C. Because 'year' is an optional property in Car.

D. Because 'myCar' is explicitly typed as Car.

Solution

1. Step 1: Identify assignment type

   The variable 'myCar' is assigned to 'car', not an object literal directly.

2. Step 2: Understand excess property checking scope

   Excess property checking only triggers on object literals, not on variables or expressions.

3. Final Answer:

   Because excess property checking only applies to object literals, not variables. -> Option B

4. Quick Check:

   Excess check skips variables [OK]

Hint: Excess check triggers only on object literals [OK]

Common Mistakes:

• Assuming optional properties cause errors
• Thinking all assignments trigger excess checks
• Believing extra properties cause runtime errors

5. You want to assign an object literal with extra properties to a variable typed by an interface without errors. Which approach correctly avoids excess property checking errors?

interface User { username: string; }
// Which option works without error?

hard

A. const user: User = { username: "john", age: 30 };

B. const user: { username: string } = { username: "john", age: 30 };

C. const user: User = { username: "john" };
user.age = 30;

D. const user: User = { username: "john", age: 30 } as User;

Solution

1. Step 1: Understand excess property checking on object literals

   Assigning an object literal with extra properties directly causes errors.

2. Step 2: Use type assertion to bypass excess property checking

   Using 'as User' tells TypeScript to trust the type, skipping excess property checks.

3. Step 3: Analyze options

   const user: User = { username: "john", age: 30 } as User; uses type assertion on the object literal, avoiding error. const user: { username: string } = { username: "john", age: 30 }; causes excess property error. const user: User = { username: "john" }; user.age = 30; tries to add property after but TypeScript errors: Property 'age' does not exist on type 'User'. const user: User = { username: "john", age: 30 }; causes excess property error.

4. Final Answer:

   const user: User = { username: "john", age: 30 } as User; -> Option D

5. Quick Check:

   Type assertion on literal skips excess check [OK]

Hint: Use 'as Type' to bypass excess property errors [OK]

Common Mistakes:

• Trying to assign extra properties directly without assertion
• Asserting variable instead of object literal
• Adding extra properties after assignment without type update