The override Keyword
Mark methods that intentionally replace a base method, and let the compiler guard the link.
When a subclass redefines a base method, it is easy to make a silent mistake: mistype the name, or keep overriding a method the base class later renamed. Your "override" then quietly becomes a brand-new, never-called method.
The override keyword closes that gap. It declares intent, and the compiler verifies a matching base member actually exists.
class Base {
greet() { return "hello"; }
}
class Sub extends Base {
override greet() { return "hi"; } // checked against Base.greet
// override gret() {} // Error: no base member named gret
}Enforce it project-wide
Turn on noImplicitOverride in tsconfig.json and TypeScript requires the keyword on every override. Now if a base method is renamed or removed, every stale override lights up immediately — a cheap, high-value safety net on any class hierarchy.
Example
When to use it
- A subclass marks its overridden speak() method with override so renaming the base method causes a compile error.
- A code review policy enforces noImplicitOverride in tsconfig so accidental shadowing of base methods is caught automatically.
- A team uses override on every intentional method override so readers can distinguish deliberate overrides from new methods.
More examples
override keyword on a method
The override keyword documents intent and causes a compile error if speak() is ever removed or renamed in the base class.
class Animal {
speak(): string { return 'some sound'; }
}
class Dog extends Animal {
override speak(): string { return 'Woof!'; }
}
console.log(new Dog().speak()); // 'Woof!'noImplicitOverride catches accidents
With noImplicitOverride enabled, any method that shadows a base method must be explicitly marked override.
// tsconfig.json
// { "compilerOptions": { "noImplicitOverride": true } }
class Base {
greet(): string { return 'hello'; }
}
class Child extends Base {
// greet(): string { return 'hi'; } // Error without override keyword
override greet(): string { return 'hi'; } // OK
}override with super call
Combines override with super.log() to extend the base behaviour, making the inheritance relationship explicit.
class Logger {
log(message: string): void {
console.log(`[LOG] ${message}`);
}
}
class TimestampLogger extends Logger {
override log(message: string): void {
super.log(`[${new Date().toISOString()}] ${message}`);
}
}
new TimestampLogger().log('started');
Discussion