Data Types & Type Coercion

JavaScript is dynamically typed — variables have no fixed type; the values inside them do, and types can change at runtime. Knowing the seven primitive types, how typeof works, and why '5' - 1 equals 4 while '5' + 1 equals '51' saves you from an entire class of bugs.

The primitive types

Everything else — objects, arrays, functions, Date, RegExp — is an object (arrays are objects with numeric keys; functions are objects you can call).

typeof: asking about a value

console.log(typeof 'hi');        // → string
console.log(typeof 42);           // → number
console.log(typeof true);         // → boolean
console.log(typeof undefined);    // → undefined
console.log(typeof null);         // → object  😱 (a 1990s bug kept for compatibility)
console.log(typeof [1, 2]);       // → object  (use Array.isArray instead)
console.log(typeof console.log);  // → function

Expected output: mostly obvious answers with two famous quirks — null and arrays report as “object”. Use Array.isArray(value) to test arrays reliably.

null vs undefined

• undefined — “nobody assigned anything”: uninitialised variables, missing return values, absent object properties.
• null — “I deliberately cleared it”: an intentional empty state.

let middleName;                 // undefined
let currentUser = null;         // nobody logged in (intentional)
console.log(middleName, currentUser);  // → undefined null

Numbers: two gotchas

console.log(0.1 + 0.2);          // → 0.30000000000000004 (floating-point IEEE 754)
console.log(0.1 + 0.2 === 0.3);  // → false ❌
console.log(Number.isInteger(7)); // → true

console.log(10 / 0);   // → Infinity
console.log(NaN + 1);  // → NaN (Not-a-Number — a result, not a type)

Never compare floats with === directly; compare with a tolerance (Math.abs(a - b) < 0.001). And remember: typeof NaN is 'number'.

Type coercion: implicit and explicit

Explicit conversion is deliberate and clear:

String(123)        // → '123'
Number('42')       // → 42
Number('12abc')    // → NaN
Boolean('')        // → false
Boolean('hi')      // → true
parseInt('42px')   // → 42   (stops at first non-digit)
parseFloat('3.5m') // → 3.5

Implicit coercion happens when operators meet mixed types — and here is the classic inconsistency:

console.log('5' + 1);   // → '51'   (+ means string concatenation here)
console.log('5' - 1);   // → 4      (- only works numerically → converts)
console.log('5' * 2);   // → 10
console.log(true + 1);  // → 2      (true → 1)

Expected output: the chart above is why + is dangerous with strings and why you should convert explicitly at the boundaries of your code (user input, API data) instead of hoping.

Truthy and falsy

Conditions coerce values to booleans. Exactly these are falsy:

if (username) { … }          // fails only for '' / null / undefined
if (items.length) { … }      // [] is truthy — check .length, not the array

The empty-array trap trips everyone once. A related question that decides which rule wins in expressions — == vs ===:

console.log(5 == '5');    // → true  (coerces first 😬)
console.log(5 === '5');   // → false (type must match too ✅)

Always use === and !== unless you have a specific reason not to.

Common mistakes

• Using == — its coercion rules are famously confusing ('' == false → true).
• Float equality — 0.1 + 0.2 === 0.3 is false forever; that is IEEE 754, not a bug in your code.
• Checking typeof against a variable — typeof x == someValue is wrong; compare to a string literal: typeof x === 'string'.
• Trusting '0' or 'false' — non-empty strings are truthy regardless of content.

Practice checklist

1. Predict, then run: '10' + '5', '10' - '5', NaN == NaN, [] == false.
2. Write a describe(value) function returning the type name — handle the array and null quirks.
3. Convert the string '25' to a number safely, guarding against NaN.

Values are useful only when you can combine them — next: Operators & Expressions.