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
Javascript · Question Set
Objects & Prototypes interview questions for placements and exams.
Questions
12
Included in this set
Subject
Javascript
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 Javascript.
In non–arrow functions, this is determined by the call site. Calling a detached method as a plain function loses the original receiver, so this is undefined in strict mode (or globalThis in sloppy mode).
"use strict";
const user = {
name: 'Ava',
say() { console.log(this && this.name); }
};
const fn = user.say;
fn(); // undefinedFor complete preparation, combine this set with full subject-wise practice for Javascript. You can also explore other subjects and sets from the links below.
Object.create(proto) creates a new object with its internal [[Prototype]] set to proto. The object starts with no own properties unless you pass a second argument with property descriptors.
const base = { greet(){ return 'hi'; } };
const o = Object.create(base);
console.log(Object.getPrototypeOf(o) === base); // true
console.log(o.greet()); // 'hi'Data descriptors can control value, writable, enumerable, configurable. Accessor descriptors can control get, set, enumerable, configurable. By default, properties defined via defineProperty are not enumerable and not configurable unless set.
const o = {};
Object.defineProperty(o, 'x', { value: 42, writable: false });
// o.x = 5; // TypeError in strict mode
console.log(Object.getOwnPropertyDescriptor(o, 'x'));Object.assign and object spread create a new object but copy references for nested objects. To deeply clone, you need a custom routine, a library, or structuredClone (for supported types).
const a = { n: 1, inner: { x: 10 } };
const b = { ...a };
b.inner.x = 99;
console.log(a.inner.x); // 99 (shallow copy)Map is designed for key–value collections with arbitrary key types and predictable iteration order. Objects are best for structured data and use string/symbol keys; they also inherit from Object.prototype unless created with null prototype.
const m = new Map();
const k = { id: 1 };
m.set(k, 'value');
console.log(m.get(k)); // 'value'
console.log([...m]);typeof reports primitive types (except that typeof null is 'object') and 'function' for functions. instanceof tests whether an object’s prototype chain contains a constructor’s prototype.
console.log(typeof 42); // 'number' console.log(typeof null); // 'object' (quirk) console.log([] instanceof Array); // true
Getters can compute a property on access; setters can validate or transform inputs. They are defined either in object literals or via Object.defineProperty with get/set.
const user = {
_age: 20,
get age(){ return this._age; },
set age(v){ if(v>=0) this._age = v; }
};
user.age = -5; // ignored by setter
console.log(user.age); // 20In JavaScript, objects inherit directly from other objects. Every object has an internal [[Prototype]] pointing to another object (or null). When a property is missing, the engine looks up the chain. This model enables sharing behavior without copying methods to each instance.
const animal = { speak(){ return '...'; } };
const dog = Object.create(animal);
dog.speak = function(){ return 'woof'; };
const beagle = Object.create(dog);
console.log(beagle.speak()); // 'woof' (found on dog, not animal)If a property is missing on the object, JavaScript consults the object’s [[Prototype]] and continues up the chain until it finds the property or reaches null. This is called prototypal inheritance and explains why objects can appear to "have" methods they never defined directly.
const proto = { kind: 'base' };
const obj = Object.create(proto);
obj.name = 'JS';
console.log(obj.kind); // 'base' (found via prototype chain)obj.hasOwnProperty('x') is true only if x is an own property. 'x' in obj returns true if x exists on the object or anywhere in its prototype chain.
const proto = { a: 1 };
const o = Object.create(proto);
o.b = 2;
console.log(o.hasOwnProperty('a')); // false
console.log('a' in o); // trueES6 class syntax is syntactic sugar over the existing prototype system. Methods declared in a class body are added to the constructor’s prototype; static methods go on the constructor itself. Inheritance (extends) sets up the prototype chain between constructors and their prototypes.
class Person { constructor(name){ this.name = name; } greet(){ return 'Hi ' + this.name; } }
class Dev extends Person { code(){ return 'coding'; } }
console.log(Object.getOwnPropertyNames(Person.prototype)); // ['constructor','greet']preventExtensions: disallows adding new properties. seal: disallows adding/removing properties and marks existing properties as non-configurable (values can still change if writable). freeze: like seal, but also makes data properties non-writable (no changes allowed to values).
const obj = { x: 1 };
Object.preventExtensions(obj);
// obj.y = 2; // TypeError in strict mode
const sealed = Object.seal({ a: 1 });
// delete sealed.a; // false
sealed.a = 5; // allowed
const frozen = Object.freeze({ b: 1 });
// frozen.b = 2; // TypeError in strict mode