Mobile App Now Available

Master Interviews
Anywhere, Anytime

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

Subject page

Javascript · Question Set

JavaScript Fundamentals – Javascript interview questions

JavaScript Fundamentals interview questions for placements and exams.

Subject: JavascriptDifficulty: Mixed15 questions in this set

Set overview

Questions

Included in this set

Subject

Javascript

Explore more sets

Difficulty

Mixed

Level of this set

Javascript – JavaScript Fundamentals questions (15)

Go through each question and its explanation. Use this set as a focused practice pack for Javascript.

Back to Javascript subject page

1. What is the difference between == and === in JavaScript?

Difficulty: EasyType: MCQTopic: JS Operators

Double equals performs loose equality with type coercion. It converts values to the same type before comparing. This causes unexpected results. Triple equals performs strict equality without type coercion. It compares both value and type. If types are different, it returns false immediately. Simple rule: Double equals is lenient, like a relaxed teacher. Triple equals is strict, like a strict teacher. Always use triple equals unless you have a specific reason not to. Real world analogy: Comparing a 5 dollar bill and a 5 euro note. Double equals says equal because both are 5. Triple equals says not equal because one is dollars and one is euros. Best practice: Always use triple equals. Most companies enforce this in coding standards.

Example code

// == (loose equality with type coercion)
console.log(5 == '5');           // true (string converted to number)
console.log(true == 1);          // true (boolean converted to number)
console.log(false == 0);         // true
console.log(null == undefined);  // true (special case)
console.log('' == 0);            // true (empty string to 0)

// === (strict equality without coercion)
console.log(5 === '5');          // false (different types)
console.log(true === 1);         // false (different types)
console.log(false === 0);        // false (different types)
console.log(null === undefined); // false (different types)
console.log('' === 0);           // false (different types)

// Dangerous examples with ==
console.log(0 == false);         // true (confusing!)
console.log('' == false);        // true (confusing!)
console.log([] == false);        // true (very confusing!)

// Safe with ===
console.log(0 === false);        // false (clear!)
console.log('' === false);       // false (clear!)
console.log([] === false);       // false (clear!)

Continue your preparation

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.

Quick navigation:Javascript subject page•All subjects

10. Explain the different types of scope in JavaScript: global, function, and block scope.

Difficulty: MediumType: SubjectiveTopic: Scope Hoisting

Scope determines where variables are accessible in your code. Global scope: Variables declared outside any function or block. Accessible everywhere in your code. In browsers, global variables become properties of window object. Be careful with globals because they can be modified from anywhere. Function scope: Variables declared inside a function. Only accessible within that function. This includes var, let, and const. Function scope creates privacy and prevents variables from leaking out. Block scope: Variables declared with let or const inside curly braces. Only accessible within that block. Blocks include if statements, for loops, while loops, or any curly braces. Block scope was introduced in ES6. Variables declared with var ignore block scope and use function scope instead. Scope chain: JavaScript uses a scope chain to look up variables. It starts in current scope. If not found, moves to parent scope. Continues until reaching global scope. If still not found, you get ReferenceError. Inner functions can access outer variables, but outer functions cannot access inner variables. Lexical scoping: JavaScript uses lexical scoping, also called static scoping. Scope is determined by where code is written, not where it is called. Inner functions remember their outer scope even after outer function finishes. This is the basis for closures. Best practices: Minimize global variables. Declare variables in smallest scope needed. Use let and const for block scope. Never rely on variable leaking from blocks.

Example code

// GLOBAL SCOPE
let globalVar = 'I am global';
var alsoGlobal = 'Me too';

function test() {
  console.log(globalVar); // Accessible everywhere
}

console.log(globalVar);   // Works

// Global variables on window (browser)
var x = 10;
console.log(window.x);    // 10

let y = 20;
console.log(window.y);    // undefined

// FUNCTION SCOPE
function calculate() {
  let result = 10 * 5;
  var temp = 100;
  
  console.log(result);    // 50
  console.log(temp);      // 100
}

// console.log(result);   // Error!
// console.log(temp);     // Error!

// BLOCK SCOPE
if (true) {
  let blockVar = 'I am block scoped';
  const alsoBlock = 'Me too';
  var notBlock = 'I leak out!';
  
  console.log(blockVar);  // Works
}

// console.log(blockVar); // Error!
console.log(notBlock);    // Works! (BAD)

// Block scope in loops
for (let i = 0; i < 3; i++) {
  console.log(i);
}
// console.log(i); // Error!

for (var j = 0; j < 3; j++) {
  // j leaks out
}
console.log(j); // 3 (leaked)

// SCOPE CHAIN
let outer = 'outer';

function first() {
  let middle = 'middle';
  
  function second() {
    let inner = 'inner';
    
    console.log(inner);  // Accessible
    console.log(middle); // Accessible
    console.log(outer);  // Accessible
  }
  
  second();
  // console.log(inner); // Error!
}

first();

11. Explain the differences between var, let, and const with examples. When should you use each?

Difficulty: MediumType: SubjectiveTopic: Scope Hoisting

Variable declared with var Has function scope. Accessible anywhere within the function, even outside blocks. This causes variable leaking. Is hoisted and initialized as undefined. You can access it before declaration. Can be redeclared in the same scope without errors. Variable declared with let: Has block scope. Only exists within curly braces. This prevents variable leaking. Is hoisted but not initialized. Stays in Temporal Dead Zone. Accessing before declaration throws ReferenceError. Cannot be redeclared in the same scope. Prevents accidental overwrites. Variable declared with const: Has block scope, just like let. Is hoisted but not initialized, stays in Temporal Dead Zone. Cannot be redeclared or reassigned. Value is locked. Important: You can modify properties of const objects or add elements to const arrays. Const prevents reassignment, not mutation. When to use each: Use const by default for 90 percent of variables. This includes objects and arrays whose contents you will modify. Use let when the value will change, like loop counters or calculations that update. Never use var in modern JavaScript. It causes problems and is banned in many companies.

Example code

// VAR - function scoped (old way, avoid this)
function testVar() {
  console.log(x); // undefined (hoisted)
  var x = 10;
  
  if (true) {
    var x = 20; // Same variable! (overwrites)
  }
  console.log(x); // 20 (changed everywhere)
}

// LET - block scoped (modern way)
function testLet() {
  // console.log(y); // ReferenceError (TDZ)
  let y = 10;
  
  if (true) {
    let y = 20; // Different variable (block scoped)
    console.log(y); // 20
  }
  console.log(y); // 10 (unchanged)
}

// CONST - cannot reassign
const PI = 3.14;
// PI = 3.15; // Error! Cannot reassign

// But can modify object contents
const person = { name: 'John' };
person.name = 'Jane';  // OK! Modifying property
person.age = 30;       // OK! Adding property
// person = {};        // Error! Cannot reassign

const numbers = [1, 2, 3];
numbers.push(4);       // OK! Modifying array
// numbers = [];       // Error! Cannot reassign

// WHEN TO USE WHAT

// Use const (default choice)
const API_URL = 'https://api.example.com';
const users = [];
const config = { timeout: 5000 };

// Use let (when value changes)
let score = 0;
score += 10;
score -= 5;

for (let i = 0; i < 5; i++) {
  console.log(i);
}

// NEVER use var (causes problems)
if (true) {
  var leaked = 'I escaped!';
}
console.log(leaked); // Works but BAD

// Loop problem with var
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 100);
}
// Prints: 3, 3, 3 (all share same i)

// Fixed with let
for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 100);
}
// Prints: 0, 1, 2 (each has own i)

13. Can you modify properties of a const object or elements of a const array? Explain why or why not.

Difficulty: MediumType: SubjectiveTopic: Scope Hoisting

Yes, you can modify the properties of a const object and the elements of a const array. In JavaScript, const only prevents reassignment of the variable, not changes to the object or array it references. So I can update properties, push or pop from an array, but I can’t make that const variable point to a completely new object or array. If I really want to make an object immutable, I’d use something like Object.freeze() on it.

Example code

// MODIFYING CONST OBJECTS
const person = {
  name: 'John',
  age: 30
};

// These all work - modifying properties
person.name = 'Jane';     // Change property
person.city = 'New York'; // Add property
delete person.age;        // Delete property

console.log(person); // { name: 'Jane', city: 'New York' }

// This fails - reassigning variable
// person = { name: 'Bob' }; // TypeError

// MODIFYING CONST ARRAYS
const numbers = [1, 2, 3];

// These all work - modifying contents
numbers.push(4);          // Add element
numbers.pop();            // Remove element
numbers[0] = 10;          // Change element

console.log(numbers); // Modified array

// This fails - reassigning variable
// numbers = [5, 6, 7]; // TypeError

// WHY IT WORKS
const obj = { x: 1 };
// obj points to memory location

obj.x = 2;  // OK - changing contents
obj.y = 3;  // OK - adding to contents

// obj = {}; // Error - trying to point elsewhere

// MAKING TRULY IMMUTABLE
const frozen = Object.freeze({ x: 1, y: 2 });

frozen.x = 10;     // Ignored
frozen.z = 3;      // Cannot add
delete frozen.y;   // Cannot delete

console.log(frozen); // { x: 1, y: 2 } (unchanged)

// SHALLOW FREEZE (only top level)
const nested = Object.freeze({
  name: 'John',
  address: { city: 'NYC' }
});

// nested.name = 'Jane';        // Cannot change
nested.address.city = 'LA';     // Can change (nested not frozen)

// PRACTICAL EXAMPLE
const shoppingCart = [];

shoppingCart.push({ item: 'Book', price: 10 });
shoppingCart.push({ item: 'Pen', price: 2 });

// But we don't want to accidentally reassign
// shoppingCart = []; // Error! Protected by const

15. List all JavaScript data types. Explain the difference between primitive and reference types.

Difficulty: EasyType: SubjectiveTopic: Data Types

In JavaScript we have two main categories of data types: primitive and reference types. The 7 primitive types are: string, number, bigint, boolean, undefined, null, and symbol. Reference types are basically objects, which include regular objects, arrays, and functions. Primitives are immutable and stored by value, so when you copy them you get a separate value. Reference types are mutable and stored by reference, so when you copy them you’re copying a reference to the same object in memory.

Example code

// 7 PRIMITIVE TYPES

// 1. String
let name = 'John';
let message = "Hello";
let template = `Hi ${name}`;

// 2. Number
let age = 25;
let price = 19.99;
let infinity = 1 / 0;    // Infinity
let notNumber = 'text' / 2; // NaN

// 3. BigInt
let huge = 9007199254740991n;

// 4. Boolean
let isActive = true;

// 5. undefined
let notAssigned;
console.log(notAssigned); // undefined

// 6. null
let empty = null;

// 7. Symbol
let id1 = Symbol('id');
let id2 = Symbol('id');
console.log(id1 === id2); // false (always unique)

// REFERENCE TYPES

let person = { name: 'John', age: 30 };
let numbers = [1, 2, 3];
function greet() { }

// PRIMITIVE vs REFERENCE BEHAVIOR

// Primitives - copy by value
let a = 5;
let b = a;  // Copy of value
b = 10;
console.log(a); // 5 (unchanged)
console.log(b); // 10

// Reference - copy by reference
let obj1 = { value: 5 };
let obj2 = obj1; // Reference to same object
obj2.value = 10;
console.log(obj1.value); // 10 (changed!)
console.log(obj2.value); // 10

// Primitive comparison
let str1 = 'hello';
let str2 = 'hello';
console.log(str1 === str2); // true (same value)

// Reference comparison
let arr1 = [1, 2, 3];
let arr2 = [1, 2, 3];
console.log(arr1 === arr2); // false (different objects)

// Primitive immutability
let text = 'hello';
text[0] = 'H';      // Ignored
console.log(text);  // 'hello' (unchanged)

// Reference mutability
let list = [1, 2, 3];
list[0] = 10;       // Changes the array
list.push(4);       // Adds to array
console.log(list);  // [10, 2, 3, 4]

Master Interviews
Anywhere, Anytime

JavaScript Fundamentals – Javascript interview questions

Set overview

Javascript – JavaScript Fundamentals questions (15)

1. What is the difference between == and === in JavaScript?

Continue your preparation

2. What will be the output of: '5' + 3 - 2

3. What happens when you access a let variable before its declaration?

4. What is the main difference between var and let?

5. What will be the output? console.log(x); var x = 5;

6. How many primitive data types are there in JavaScript?

7. What does typeof null return in JavaScript?

8. What is the key difference between null and undefined?

9. How many falsy values are there in JavaScript?

10. Explain the different types of scope in JavaScript: global, function, and block scope.

11. Explain the differences between var, let, and const with examples. When should you use each?

12. What is hoisting in JavaScript? Explain how it works for variables and functions with examples.

13. Can you modify properties of a const object or elements of a const array? Explain why or why not.

14. What is JavaScript primarily used for?

15. List all JavaScript data types. Explain the difference between primitive and reference types.

More sets in Javascript

Explore related subjects

Master Interviews Anywhere, Anytime

JavaScript Fundamentals – Javascript interview questions

Set overview

1. What is the difference between == and === in JavaScript?

Continue your preparation

2. What will be the output of: '5' + 3 - 2

3. What happens when you access a let variable before its declaration?

4. What is the main difference between var and let?

5. What will be the output? console.log(x); var x = 5;

6. How many primitive data types are there in JavaScript?

7. What does typeof null return in JavaScript?

8. What is the key difference between null and undefined?

9. How many falsy values are there in JavaScript?

10. Explain the different types of scope in JavaScript: global, function, and block scope.

11. Explain the differences between var, let, and const with examples. When should you use each?

12. What is hoisting in JavaScript? Explain how it works for variables and functions with examples.

13. Can you modify properties of a const object or elements of a const array? Explain why or why not.

14. What is JavaScript primarily used for?

15. List all JavaScript data types. Explain the difference between primitive and reference types.

More sets in Javascript

Explore related subjects

Master Interviews
Anywhere, Anytime