JavaScript Data Types

1. What is a Data Type?

A data type defines the kind of value a piece of data represents, how much memory it occupies, and what mathematical or logical operations can be performed on it.

JavaScript is dynamically typed (loosely typed). You do not declare variable types explicitly (like int or String in Java/C++). Instead, types are attached to the underlying value at runtime.

let value = 42;        // Currently holding a Number
value = "Hello";       // Now holding a String
value = true;          // Now holding a Boolean

2. The 7 Primitive Types

JavaScript has 7 primitive data types. Primitives hold raw values directly in Call Stack memory and are immutable.

let age = 25;                       // Integer
let price = 99.99;                   // Decimal float
let safeMax = Number.MAX_SAFE_INTEGER; // 9007199254740991
let inf = 1 / 0;                     // Infinity
let notANum = 0 / 0;                 // NaN

3. Primitive vs Reference Types (Memory Model)

How JavaScript values live and behave in memory is the single most tested concept in technical interviews:

let x = 10;
let y = x; // independent copy
y = 20;

console.log(x); // 10 (untouched)
console.log(y); // 20

let userA = { score: 100 };
let userB = userA; // copies pointer
userB.score = 999;

console.log(userA.score); // 999 (altered!)
console.log(userB.score); // 999

4. The typeof Operator

The typeof unary operator returns a string indicating the type of the unevaluated operand.

5. The typeof null Quirk (Interview Classic)

6. Special Numbers: NaN, Infinity, and -Infinity

JavaScript includes three special numeric values within the number data type:

Why NaN is unique in JavaScript:

NaN is the only value in JavaScript that is not equal to itself:

console.log(NaN === NaN); // false ❌

// How to reliably check for NaN:
console.log(Number.isNaN(NaN));      // true ✅ (Strict, reliable)
console.log(Object.is(NaN, NaN));    // true ✅ (ES6 SameValue equality)

// ⚠️ Warning: The global isNaN() coerces values before checking:
console.log(isNaN("hello"));         // true (coerces "hello" -> NaN)
console.log(Number.isNaN("hello"));  // false (does NOT coerce, strictly checks)

false
true
true
true
false

7. Type Conversion: Explicit vs Implicit Coercion

Type conversion converts a value from one data type to another. It occurs in two ways:

A. Explicit Type Conversion (Intentional & Predictable)

Developers manually convert types using built-in wrapper functions:

String(123);       // "123"
String(true);      // "true"
String(null);      // "null"
String(undefined); // "undefined"
String([1, 2]);    // "1,2"

Number("42");      // 42
Number("  123  "); // 123
Number("");        // 0
Number("abc");     // NaN
Number(true);      // 1 (false -> 0)
Number(null);      // 0 (undefined -> NaN)

Boolean(1);        // true (0 -> false)
Boolean("Hello");  // true ("" -> false)
Boolean([]);       // true (objects truthy)
Boolean({});       // true
Boolean(null);     // false
Boolean(undefined);// false

B. Implicit Coercion (Automatic Runtime Coercion)

JavaScript automatically converts types behind the scenes when operators encounter mismatched types:

"5" + 2;         // "52"
1 + "2" + 3;     // "123"
1 + 2 + "3";     // "33" (1+2=3, "3"+"3"="33")
"Hi " + true;    // "Hi true"

"5" - 2;         // 3
"10" * "2";      // 20
"10" / "2";      // 5
"abc" - 2;       // NaN

5 == "5";          // true (coerced)
5 === "5";         // false (different types)
null == undefined; // true (spec exception)
null === undefined;// false

8. Truthy and Falsy Values

In JavaScript, every value is inherently either truthy or falsy when evaluated inside a boolean context (such as an if condition, logical operator, or Boolean() call).

9. Mutability: Primitives vs Objects

Understanding mutability prevents accidental state corruption bugs:

• Primitives are Immutable: Once a primitive value is created in memory, its character sequence or numeric value can never be altered. String methods like .toUpperCase() or .trim() return a brand-new string; they never modify the original.
• Objects are Mutable: Object keys and array elements can be added, updated, or deleted in place without changing the memory reference address.

// Primitive Immutability
let word = "hello";
word[0] = "H"; // Silently fails (or throws in strict mode)
console.log(word); // "hello" (Unchanged!)

let upperWord = word.toUpperCase(); // Creates a brand-new string
console.log(word);      // "hello" (Original intact)
console.log(upperWord); // "HELLO"

// Object Mutability
const user = { name: "Alex" };
user.name = "Sam"; // Mutates object in place
user.role = "Admin";
console.log(user); // { name: 'Sam', role: 'Admin' }

10. 🎯 Placement & Interview Quiz (8 Output Traps)

Test your mastery of data types, coercion, and evaluation traps commonly asked in technical screening interviews. Answer each question one by one:

console.log(typeof null);

console.log(NaN === NaN);

console.log(typeof NaN);

console.log(1 < 2 < 3);
console.log(3 > 2 > 1);

console.log(Boolean([]));

console.log("5" + 2);

console.log("5" - 2);

const a = { score: 10 };
const b = a;
b.score = 99;

console.log(a.score);

11. Common Data Type Mistakes & How to Avoid Them

12. Quick Revision Reference Table

13. Interactive Practice Challenge