Interview Questions
Objects can be created using object literals, constructor functions, Object.create(), and class syntax. Object literals provide simple key-value structure. Constructor functions enable prototype-based inheritance. Classes offer more familiar OOP syntax. Consider encapsulation needs and inheritance requirements when choosing creation method.
Prototypal inheritance uses prototype chain for property/method lookup, objects inherit directly from other objects. Classical inheritance uses class blueprints. Prototypal offers more flexibility but requires careful handling of prototype chain. Consider performance implications and inheritance depth.
Property descriptors control property behavior through attributes: writable, enumerable, configurable, get/set. Object.defineProperty() sets descriptors. Affects property modification, enumeration, deletion. Consider immutability needs and access control requirements.
Private fields implemented using # prefix in classes, closures for privacy in constructor functions, WeakMap for truly private data. Consider encapsulation requirements, compatibility needs. Handle inheritance of private members appropriately.
Object.create() establishes direct prototype link without constructor call. Constructor functions create instances with new keyword, initialize with constructor code. Object.create() offers more control over property descriptors. Consider initialization needs and prototype chain requirements.
Return this from methods to enable chaining. Ensures methods return object instance. Consider immutability implications, error handling in chain. Implement proper method dependencies. Document chain requirements and limitations.
Mixins combine properties/methods from multiple sources into objects. Alternative to multiple inheritance. Implement using Object.assign() or custom mixing functions. Consider property conflicts, initialization order. Handle method composition properly.
Getters/setters enable computed properties, access control. Defined using get/set keywords or Object.defineProperty(). Enable validation, computed values. Consider performance implications of computations. Handle recursive calls properly.
SOLID principles guide OOP design: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion. Apply through proper class/object design. Consider JavaScript's dynamic nature when implementing. Ensure maintainable, extensible code.
Observer pattern enables event-driven communication between objects. Implement subscribe/unsubscribe methods, notification mechanism. Consider memory management, event handling. Handle observer lifecycle properly. Implement cleanup for removed observers.
Factory pattern centralizes object creation logic. Enables flexible instance creation, encapsulates initialization. Consider configuration options, inheritance requirements. Handle error cases properly. Document factory interface and options.
Compose objects using delegation, aggregation, or mixing. Favor composition over inheritance. Consider interface design, dependency management. Handle lifecycle of composed objects. Implement proper cleanup procedures.
Classes provide cleaner syntax, enforce new usage, enable private fields. Constructor functions offer more flexibility, explicit prototype manipulation. Classes automatically run in strict mode. Consider compatibility requirements and feature needs.
Use appropriate enumeration method: Object.keys() for own enumerable properties, for...in for all enumerable properties including prototype chain. Consider property descriptors, inheritance. Handle non-enumerable properties when needed.
Singleton ensures single instance existence. Implement using static property/closure. Consider lazy initialization, thread safety. Handle instance access properly. Document usage restrictions and initialization requirements.
Override methods by redefining in child class/object. Access parent methods using super keyword or prototype chain. Consider composition alternatives. Handle proper method signature matching. Document overridden behavior.
Symbols create unique property keys, enable metaprogramming features. Used for private-like properties, special methods (iterators). Consider well-known symbols, property conflicts. Handle symbol description and registration appropriately.
Implement custom equality methods, compare relevant properties. Consider deep vs shallow comparison. Handle circular references, type differences. Implement proper value comparison logic. Document comparison criteria.
Module pattern uses closures for encapsulation. Modern alternatives include ES modules, classes with private fields. Consider compatibility requirements, encapsulation needs. Handle initialization and cleanup properly.
Use JSON.stringify/parse with custom replacer/reviver. Handle circular references, special types (Date, Map). Consider security implications, data validation. Implement proper error handling. Document serialization format.
Command pattern encapsulates actions as objects. Enables undo/redo, action queuing. Consider command validation, execution context. Handle command parameters properly. Implement proper error handling and rollback.
Use Object.freeze(), implement proper copying methods. Consider deep freezing requirements. Handle updates through new object creation. Implement efficient update patterns. Document immutability guarantees.
Proxies enable custom behavior for fundamental operations. Implement property access control, validation, logging. Consider performance implications. Handle trap implementation properly. Document proxy behavior and limitations.
Strategy pattern enables interchangeable algorithms. Implement through object composition, function properties. Consider strategy selection logic, default strategies. Handle strategy initialization and switching properly.
Decorator pattern adds behavior dynamically. Implement through object composition or class inheritance. Consider decoration order, interface consistency. Handle proper method delegation. Document decorator capabilities.
Implement proper initialization, cleanup methods. Handle resource management, event listeners. Consider garbage collection implications. Implement proper destruction sequence. Document lifecycle requirements.
Value objects represent immutable values, implement value equality. Consider hash code implementation, comparison methods. Handle proper immutability. Document value semantics and usage.
Pass dependencies through constructor or setter methods. Consider dependency lifecycle, initialization order. Handle optional dependencies properly. Implement proper dependency validation. Document dependency requirements.
Follow SOLID principles, use appropriate patterns. Consider JavaScript's prototype nature. Handle proper encapsulation, inheritance. Implement clear interfaces. Document design decisions and rationale.