Merging classes with interfaces in Typescript - Step-by-Step Execution

Concept Flow - Merging classes with interfaces

Define class

↓

Define interface with same name

↓

TypeScript merges interface into class type

↓

Class instances have combined type

↓

Use merged properties and methods

TypeScript merges an interface with the same name as a class, combining their types so class instances have all properties and methods.

Execution Sample

Typescript

class User {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
}
interface User {
  age: number;
}

Defines a class User and an interface User with an extra property; TypeScript merges them so User instances have both.

Execution Table

Step	Action	Evaluation	Result
1	Define class User with property name and constructor	Class User created	User has property 'name' and constructor
2	Define interface User with property age	Interface User created	Interface User has property 'age'
3	TypeScript merges interface User into class User type	Merged type includes 'name' and 'age'	User type now has properties 'name' and 'age'
4	Create instance: const u = new User('Alice')	Instance u created	u.name = 'Alice', u.age is undefined (needs assignment)
5	Assign u.age = 30	Property age assigned	u.age = 30
6	Access u.name and u.age	Read properties	Outputs: name='Alice', age=30
7	End of example	No more steps	Execution stops

💡 All steps executed; merged class and interface types combined successfully

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
u.name	undefined	'Alice'	'Alice'	'Alice'
u.age	undefined	undefined	30	30

Key Moments - 2 Insights

Why does the instance 'u' not have 'age' immediately after creation?

Because the class constructor only sets 'name'. The 'age' property comes from the merged interface and must be assigned separately, as shown in step 5.

How does TypeScript know to merge the interface with the class?

TypeScript merges declarations with the same name automatically, combining their types into one, as seen in step 3.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'u.age' after step 4?

A undefined

B 30

C 0

D 'Alice'

💡 Hint

Check the variable_tracker column 'After Step 4' for 'u.age'

At which step does 'u.age' get assigned a value?

A Step 3

B Step 5

C Step 4

D Step 6

💡 Hint

Look at the execution_table row describing property assignment

If the interface 'User' had a method instead of a property, what would happen?

A The method would be ignored

B The class would automatically have the method implementation

C TypeScript would merge the method signature, but class must implement it

D The code would cause a runtime error

💡 Hint

Recall that interfaces add type info but do not provide implementations

Concept Snapshot

Merging classes with interfaces in TypeScript:
- Define a class and an interface with the same name.
- TypeScript merges their types automatically.
- Class instances have combined properties.
- Interface adds type info; class provides implementation.
- Properties from interface must be assigned if not in constructor.

Full Transcript

This example shows how TypeScript merges a class and an interface with the same name. First, a class User is defined with a name property and constructor. Then, an interface User is defined with an age property. TypeScript merges these so the User type has both name and age. When creating an instance u of User, only name is set by the constructor. The age property must be assigned separately. This merging allows extending class types with interfaces for flexible typing.