Class Constructor in TypeScript
In TypeScript, a class constructor is a special method used to initialize an object when a class is instantiated.
It’s very similar to JavaScript, but TypeScript adds strong typing, access modifiers, and shortcuts.
1. Basic constructor
class User {
name: string;
age: number;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
}
const user = new User("Alice", 30);
What’s happening
constructor runs automatically when new User(...) is called
It assigns initial values to class properties
Parameters are typed
2. Constructor parameters are typed
TypeScript enforces correct types:
new User("Alice", 30); // ✅
new User(30, "Alice"); // ❌ Type error
This prevents runtime bugs at compile time.
3. Parameter properties (TypeScript shortcut)
TypeScript provides a shorthand to declare and initialize properties directly in the constructor.
class User {
constructor(
public name: string,
private age: number
) {}
}
This is equivalent to:
class User {
public name: string;
private age: number;
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
}
✅ Very common in real-world TS
✅ Less boilerplate
4. Access modifiers in constructors
You can use access modifiers in constructor parameters:
public → accessible everywhere
private → only inside the class
protected → class + subclasses
readonly → cannot be changed after initialization
class Product {
constructor(
public name: string,
readonly price: number
) {}
}
const p = new Product("Book", 20);
p.price = 25; // ❌ Error (readonly)
5. Optional constructor parameters
Use ? or default values.
Optional parameter
class User {
constructor(public name: string, public age?: number) {}
}
Default value
class User {
constructor(public name: string, public age: number = 18) {}
}
6. Multiple constructors? (Not directly)
TypeScript does not support multiple constructors, but you can simulate them using optional parameters or union types.
class Point {
x: number;
y: number;
constructor(x: number, y?: number) {
this.x = x;
this.y = y ?? 0;
}
}
7. Constructor with inheritance (super)
When extending a class, you must call super() before using this.
class Animal {
constructor(public name: string) {}
}
class Dog extends Animal {
constructor(name: string, public breed: string) {
super(name); // required
}
}
❌ Using this before super() causes an error.
8. Constructors and interfaces
Constructors themselves cannot be defined in interfaces, but the shape of the instance can be.
interface UserShape {
name: string;
}
class User implements UserShape {
constructor(public name: string) {}
}
9. When constructors run
class Logger {
constructor() {
console.log("Instance created");
}
}
new Logger(); // logs immediately
Constructors run once per instance.
10. Common best practices
✅ Use parameter properties to reduce boilerplate
✅ Keep constructors lightweight (no heavy logic)
✅ Validate inputs if needed
❌ Avoid async constructors (not supported)
Quick summary
constructor initializes a class instance
Parameters are strongly typed
Access modifiers can be declared in constructor params
readonly prevents reassignment
super() is required in subclasses
Only one constructor per class
In questa pagina del sito puoi guardare il video online Class Constructor in TypeScript della durata di ore minuti seconda in buona qualità , che l'utente ha caricato Learn Language Hub 28 dicembre 2025, condividi il link con amici e conoscenti, su youtube questo video è già stato visto 7 volte e gli è piaciuto 0 spettatori. Buona visione!
