Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
Typescript · Question Set
OOP & Mixins interview questions for placements and exams.
Questions
13
Included in this set
Subject
Typescript
Explore more sets
Difficulty
Mixed
Level of this set
Go through each question and its explanation. Use this set as a focused practice pack for Typescript.
Interfaces are easy to extend, merge, and use with classes. Use types when you need unions, intersections, or advanced mapped/conditional types.
interface Animal { speak(): void }
class Dog implements Animal { speak() { /* ... */ } }For complete preparation, combine this set with full subject-wise practice for Typescript. You can also explore other subjects and sets from the links below.
public (default) is visible everywhere, private is only inside the class, protected is inside the class and its subclasses, readonly prevents reassignment of that property after construction.
class User {
public id: string;
protected role: string = 'user';
private secret = 'shh';
readonly createdAt = new Date();
constructor(id: string){ this.id = id; }
}Abstract classes can include implemented methods plus abstract methods that subclasses must provide. You cannot instantiate an abstract class directly.
abstract class Shape {
abstract area(): number;
describe(){ return 'I am a shape'; }
}
class Square extends Shape { constructor(public s: number){ super(); }
area(){ return this.s * this.s; }
}You can add a fake first parameter named `this` to type the `this` context. It isn’t emitted at runtime—it’s only for type checking.
function move(this: { x: number; y: number }, dx: number, dy: number){
this.x += dx; this.y += dy;
}
const p = { x: 0, y: 0, move };
p.move(1,2);A mixin takes a base class and returns a new class with extra behavior. It’s composition: `const WithX = <TBase extends Constructor>(Base: TBase) => class extends Base { … }`.
type Ctor<T = {}> = new (...args: any[]) => T;
function WithTimestamp<TBase extends Ctor>(Base: TBase){
return class extends Base { timestamp = Date.now(); };
}
class Model {}
class TimedModel extends WithTimestamp(Model) {}readonly blocks reassigning the property, but it doesn’t deep-freeze nested objects. `as const` applies to expressions and narrows literals; `readonly` is a member-level modifier.
class Config { readonly host = 'localhost'; }
const c = new Config();
// c.host = 'x'; // ❌ cannot assign to 'host' because it is a read-only propertyUse `super(...)` as the first statement in the subclass constructor to run the base class initialization.
class A { constructor(public id: string) {} }
class B extends A { constructor(){ super('b'); } }Interfaces: great for object shapes and class contracts; they can extend each other and merge across declarations. Types: great for unions/intersections and type transforms. Use interface when you want open, extendable shapes; use type when you need composition like `A | B` or `A & B` or mapped/conditional types.
interface Api { get(id: string): Promise<string> }
interface Api { list(): Promise<string[]> } // merges
// unions/intersections are easier with type
type Id = string | number;
type UserView = { id: string } & { name: string };Use interfaces for contracts (what methods exist). Use abstract classes for shared implementation. Prefer composition to add features (e.g., Logging, Caching) without deep hierarchies. Inheritance fits when subclasses truly are specializations of one base behavior.
interface Repository<T> { get(id: string): Promise<T>; save(x: T): Promise<void>; }
abstract class BaseRepo<T> implements Repository<T> {
constructor(protected store: Map<string, T>) {}
abstract validate(x: T): void;
async get(id: string){ return this.store.get(id)! }
async save(x: T){ this.validate(x); /*...*/ }
}
// Composition: wrap repo with a caching layer instead of subclass explosionCreate a mixin that adds `on`, `off`, and `emit` to any base class. Type the internal map and ensure `this` is the instance using a generic constructor signature.
type Ctor<T = {}> = new (...a: any[]) => T;
function WithEvents<TBase extends Ctor>(Base: TBase){
return class extends Base {
private _events = new Map<string, Set<Function>>();
on(event: string, handler: Function){
const set = this._events.get(event) ?? new Set();
set.add(handler); this._events.set(event, set);
}
off(event: string, handler: Function){ this._events.get(event)?.delete(handler); }
emit(event: string, ...args: any[]){ this._events.get(event)?.forEach(h => h(...args)); }
};
}
class Model {}
class EventedModel extends WithEvents(Model) {}
const m = new EventedModel();
m.on('save', (x: any) => console.log('saved', x));
m.emit('save', { id: 1 });public is accessible anywhere, protected is only inside the class and subclasses, private is only inside the class. Use protected for extension points and private to hide internals.
class Account {
public id: string;
protected balance = 0;
private pin = 1234;
constructor(id: string){ this.id = id; }
deposit(amount: number){ this.balance += amount; }
}
class Savings extends Account {
accrue(){ this.balance += 1; /* ok: protected */ }
// this.pin; // ❌ private: not accessible here
}
const a = new Savings('A1');
a.id; // ✅ public
// a.balance // ❌ protected
// a.pin // ❌ privateInterfaces with the same name merge into a single interface. Type aliases do not merge—redeclaring the same type name is an error.
interface Box { id: string }
interface Box { size: number }
// Merged => interface Box { id: string; size: number }Interfaces describe the shape (what methods/properties exist). Classes provide the actual code (how they work) and can implement interfaces.
interface Repo { get(id: string): Promise<string> }
class MemoryRepo implements Repo { async get(id: string){ return id; } }