JavaScript Revision Part 1 – Variables & Data Types

JavaScript variables and data types form the foundation of the language. Understanding how values are stored, copied, and identified is essential for writing efficient code and answering common interview questions.

This guide provides a quick revision of the most important concepts with concise explanations and practical examples.

Topics Covered

• Variables

• var

• let

• const

• Primitive Data Types

• Non-Primitive Data Types

• Pass by Value vs Pass by Reference

• undefined vs null

• undefined vs not defined

• NaN

• typeof Operator

---

Variables

Definition

A variable is a named container used to store data in memory so it can be accessed, updated, and reused throughout a program.

Explanation

Instead of using hardcoded values multiple times, we store them in variables. JavaScript is a dynamically typed language, so a variable can hold any type of value.

Example

let name = "Aditya";
let age = 20;
let isStudent = true;

Important Points

• Used to store data.

• Can hold any data type.

• Makes code reusable and maintainable.

---

var

Definition

var is the original way of declaring variables in JavaScript. It is function-scoped, can be redeclared, and can be reassigned.

Explanation

Before ES6, developers used var for every variable. Since it ignores block scope and allows redeclaration, it can lead to unexpected behavior. For this reason, it is rarely used in modern JavaScript.

Example

var age = 20;

var age = 25;

age = 30;

Important Points

• Function scoped

• Can be redeclared

• Can be reassigned

• Hoisted and initialized with undefined

• Avoid using var in modern JavaScript

---

let

Definition

let is a block-scoped variable introduced in ES6. It allows reassignment but does not allow redeclaration within the same scope.

Explanation

Unlike var, let respects block scope, making it safer to use inside loops, conditions, and functions.

Example

let age = 20;

age = 21;

let age = 20;
let age = 25; // SyntaxError

Important Points

• Block scoped

• Cannot be redeclared

• Can be reassigned

• Hoisted but remains in the Temporal Dead Zone until initialization

---

const

Definition

const declares a block-scoped variable whose reference cannot be reassigned after initialization.

Explanation

Use const for values that should not be reassigned. For objects and arrays, only the reference is constant, not the contents.

Example

const user = {
  name: "Aditya",
};

user.name = "Rahul"; // Valid

user = {}; // Error

Important Points

• Block scoped

• Cannot be redeclared

• Cannot be reassigned

• Must be initialized during declaration

• Object and array contents can still be modified

---

var vs let vs const

Feature	var	let	const
Scope	Function	Block	Block
Redeclare	Yes	No	No
Reassign	Yes	Yes	No
Hoisted	Yes	Yes	Yes
Temporal Dead Zone	No	Yes	Yes

---

Primitive Data Types

Definition

Primitive data types are immutable values that store the actual value directly.

Explanation

Primitive values are copied when assigned to another variable. Modifying one variable does not affect the other because each variable stores its own copy.

JavaScript has 7 primitive data types:

• String

• Number

• Boolean

• Undefined

• Null

• Symbol

• BigInt

Example

let a = 10;
let b = a;

b = 20;

console.log(a);

Output

10

Important Points

• Immutable

• Stored by value

• Compared by value

• Independent copies are created during assignment

---

Non-Primitive Data Types

Definition

Non-primitive data types are objects that store a reference to the actual data instead of the data itself.

Explanation

When an object or array is assigned to another variable, JavaScript copies the reference, not the object. Both variables point to the same memory location.

Examples include:

• Object

• Array

• Function

• Date

• Map

• Set

Example

const user1 = {
  name: "Aditya",
};

const user2 = user1;

user2.name = "Rahul";

console.log(user1.name);

Output

Rahul

Important Points

• Mutable

• Stored by reference

• Compared by reference

• Multiple variables can reference the same object

---

Pass by Value vs Pass by Reference

Pass by Value

Definition

Pass by value means a copy of the original value is assigned or passed.

Explanation

Changing the copied value does not affect the original because both variables store separate copies.

Example

let a = 10;
let b = a;

b = 20;

console.log(a);

Output

10

---

Pass by Reference

Definition

For objects, JavaScript copies the reference to the object instead of creating a new object.

Explanation

Both variables point to the same object. Any modification made through one variable is visible through the other.

Example

const obj1 = {
  name: "John",
};

const obj2 = obj1;

obj2.name = "Alex";

console.log(obj1.name);

Output

Alex

Key Differences

Feature	Pass by Value	Pass by Reference
Applies To	Primitive Types	Objects
Copy Created	Yes	No
Memory Shared	No	Yes
Original Value Changes	No	Yes

Interview Note: JavaScript is technically pass-by-value. For objects, the value being copied is the reference, which is why changes are reflected in all variables pointing to the same object.

---

Undefined vs Null

Undefined

Definition

undefined is the default value assigned to a variable that has been declared but not initialized.

Example

let age;

console.log(age);

Output

undefined

Null

Definition

null represents an intentional absence of value assigned by the developer.

Example

let user = null;

Key Differences

Undefined	Null
Assigned by JavaScript	Assigned by Developer
Variable has no value yet	Variable intentionally has no value
Type is undefined	typeof null returns "object"

Undefined vs Not Defined

Undefined

A variable exists but has not been assigned a value.

let city;

console.log(city);

Output

undefined

---

Not Defined

A variable has never been declared.

console.log(city);

Output

ReferenceError: city is not defined

Key Differences

Undefined	Not Defined
Variable exists	Variable doesn't exist
Returns undefined	Throws ReferenceError

NaN

Definition

NaN stands for Not a Number and represents an invalid numeric result.

Explanation

It is returned when a mathematical operation cannot produce a valid number.

Example

console.log(Number("Hello"));

Output

NaN

Another common interview question:

console.log(NaN === NaN);

Output

false

Use Number.isNaN() to check whether a value is NaN.

Important Points

• Type of NaN is number

• NaN is not equal to itself

• Use Number.isNaN() instead of == or ===

---

typeof Operator

Definition

The typeof operator is used to determine the data type of a value.

Explanation

It returns a string representing the type of the operand. It is commonly used for type checking in JavaScript.

Example

typeof "Hello";      // "string"
typeof 10;           // "number"
typeof true;         // "boolean"
typeof undefined;    // "undefined"
typeof Symbol();     // "symbol"
typeof 10n;          // "bigint"
typeof {};           // "object"
typeof [];           // "object"
typeof function(){}; // "function"
typeof null;         // "object"

Important Points

• Returns the type as a string.

• Arrays return "object".

• Functions return "function".

• typeof null returns "object" due to a legacy JavaScript behavior.

Interview Questions

1. What is the difference between var, let, and const?

2. What is the difference between function scope and block scope?

3. Explain primitive and non-primitive data types.

4. What is the difference between pass by value and pass by reference?

5. What is the difference between undefined and null?

6. What is the difference between undefined and not defined?

7. What is NaN? Why is NaN !== NaN?

8. Why does typeof null return "object"?

9. Why does typeof [] return "object"?

10. How does the typeof operator work?