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
JavaScript Core Interview Essentials interview questions for placements and exams.
Questions
13
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.
The loose equality operator (==) allows type coercion before comparison, which can lead to surprising results. The strict equality operator (===) checks both value and type without coercion and is generally safer in most comparisons.
console.log(5 == '5'); // true (coercion) console.log(5 === '5'); // false (different types)
For complete preparation, combine this set with full subject-wise practice for Javascript. You can also explore other subjects and sets from the links below.
Synchronous logs run first, then microtasks (Promises) run before macrotasks (setTimeout).
console.log('Start');
setTimeout(() => console.log('Timeout'), 0);
Promise.resolve().then(() => console.log('Promise'));
console.log('End');Arrow functions do not create their own this; instead, they use the this from the enclosing scope. This makes them great for callbacks, but not suitable as methods or constructors.
const obj = {
name: 'Ava',
regular(){ console.log(this.name); },
arrow: () => console.log(this && this.name)
};
obj.regular(); // 'Ava'
obj.arrow(); // undefined (lexical this from module/global scope)All declarations are hoisted. var is initialized to undefined, while let/const exist in the TDZ until their declaration is evaluated, preventing access before initialization.
// console.log(a); // undefined (var) // console.log(b); // ReferenceError (TDZ) var a = 1; let b = 2; const c = 3;
If a property isn’t found on the object itself, JavaScript continues searching in the object’s [[Prototype]] chain until it finds the property or reaches null.
const proto = { kind: 'proto' };
const obj = Object.create(proto);
obj.name = 'JS';
console.log(obj.kind); // 'proto' via prototypeundefined is the default value for uninitialized variables or missing properties. null is an explicit assignment indicating 'no value'. Note: typeof null returns 'object' due to a historical quirk.
let a; const b = null; console.log(a === undefined); // true console.log(b === null); // true console.log(typeof null); // 'object'
Debounce delays execution until a burst of events stops. Use it for search input or resize handlers so a function runs only after the user stops typing/resizing. Throttle guarantees execution at most once per interval during a continuous event stream. Use it for scroll or mousemove to run a handler at a controlled rate. Both techniques improve performance and user experience.
// Debounce
function debounce(fn, delay){
let t; return (...args) => { clearTimeout(t); t = setTimeout(() => fn(...args), delay); };
}
// Throttle
function throttle(fn, interval){
let last = 0; return (...args) => {
const now = Date.now();
if (now - last >= interval){ last = now; fn(...args); }
};
}A closure occurs when an inner function remembers and can access variables from its outer function’s scope, even after the outer function has finished executing. Closures are used for data privacy, function factories, and maintaining state across calls. Typical use cases include counters, once-only initializers, and event handlers.
function makeCounter() {
let count = 0;
return () => ++count;
}
const inc = makeCounter();
console.log(inc()); // 1
console.log(inc()); // 2call(thisArg, ...args) and apply(thisArg, argsArray) invoke the function immediately with a specified this. bind(thisArg, ...args) returns a new function with this and optional arguments pre-set.
function add(a, b){ return this.x + a + b; }
const ctx = { x: 10 };
console.log(add.call(ctx, 1, 2)); // 13
console.log(add.apply(ctx, [1, 2])); // 13
const bound = add.bind(ctx, 1);
console.log(bound(2)); // 13Promise.all resolves to an array of results if all promises resolve, and rejects on the first rejection. Promise.race settles as soon as any input promise settles (resolve or reject).
Promise.all([p1, p2])
.then(vals => console.log(vals))
.catch(err => console.error('ALL reject', err));
Promise.race([p1, p2])
.then(val => console.log('RACE', val))
.catch(err => console.error('RACE reject', err));JavaScript runs on a single thread. Synchronous code executes first; asynchronous callbacks are queued. The event loop pulls tasks (macrotasks) like setTimeout and I/O. After each task, the engine drains the microtask queue (Promises, queueMicrotask) before the next macrotask and before painting. Understanding this ordering explains why Promise callbacks often run before setTimeout(…, 0).
console.log('A');
queueMicrotask(() => console.log('microtask'));
setTimeout(() => console.log('macrotask'), 0);
console.log('B');
// A, B, microtask, macrotaskIn JavaScript, the Temporal Dead Zone (TDZ) is: The time between entering a scope and the actual line where a let or const variable is declared, during which you cannot access that variable. Even though let and const are hoisted, they are not initialized until their declaration is executed. If you try to use them before that point, you get a ReferenceError, not undefined.
console.log(x); // ❌ ReferenceError: Cannot access 'x' before initialization let x = 10;
Strict mode, enabled by the directive "use strict";, is a feature in JavaScript introduced in ECMAScript 5 that enforces stricter parsing and error handling on code at runtime. It helps developers write cleaner, safer, and more secure code by catching common mistakes and enforcing a more robust set of rules. trict mode makes several changes to normal JavaScript semantics: Eliminates some JavaScript silent errors by changing them to throw errors. Fixes mistakes that make it difficult for JavaScript engines to perform optimizations: strict mode code can sometimes be made to run faster than identical code that's not strict mode. Prohibits some syntax likely to be defined in future versions of ECMAScript.