Variables, Types & Coercion

JavaScript has eight data types: seven primitives and one non-primitive. Getting this model right from the start prevents entire classes of bugs and makes coercion predictable instead of mysterious.

var, let, and const

var is function-scoped and hoisted to the top of its containing function — it exists (as undefined) before the line that declares it. let and const are block-scoped and exist in a temporal dead zone (TDZ) from the start of the block until the declaration line is reached; accessing them in the TDZ throws a ReferenceError.

console.log(a); // undefined (hoisted)
var a = 1;

console.log(b); // ReferenceError (TDZ)
let b = 2;

Prefer const by default. Use let when you need to reassign. Avoid var in modern code — its function-level scoping causes subtle bugs in loops and callbacks.

The Seven Primitive Types

Everything else — arrays, objects, functions, dates — is an object.

typeof and its quirk

typeof "hi"        // "string"
typeof 42          // "number"
typeof true        // "boolean"
typeof undefined   // "undefined"
typeof Symbol()    // "symbol"
typeof 42n         // "bigint"
typeof {}          // "object"
typeof []          // "object"   ← arrays are objects
typeof null        // "object"   ← historical bug, never fixed
typeof function(){} // "function" ← functions get a special tag

== vs ===

=== (strict equality) requires the same type and the same value — no coercion happens. == (abstract equality) first runs a type coercion algorithm before comparing, which produces genuinely surprising results:

0 == false     // true  — false coerces to 0
"" == false    // true  — both coerce to 0
null == undefined // true  — the one deliberate exception
null == 0      // false — null only loosely equals undefined
NaN == NaN     // false — NaN is never equal to anything

Always use === unless you specifically need the null == undefined behaviour (e.g., checking if a value is either).

Truthy and Falsy

Every value is either truthy or falsy when evaluated in a boolean context (an if condition, a && / || expression, a ternary).

Falsy values — exactly these six:

• false
• 0 (and -0, 0n)
• "" (empty string)
• null
• undefined
• NaN

Everything else — including [], {}, and "false" — is truthy.

// Guard pattern
function greet(name?: string) {
  const display = name || "stranger"; // falsy name falls back
  console.log(`Hello, ${display}`);
}

Further Learning

Search these terms to go deeper:

• “You Don’t Know JS: Types & Grammar” — Kyle Simpson’s authoritative deep-dive into JS types (free on GitHub)
• “JavaScript type coercion explained” on freeCodeCamp — thorough walkthrough of the Abstract Equality Comparison algorithm
• “MDN: Equality comparisons and sameness” — official reference covering ==, ===, and Object.is
• “temporal dead zone JavaScript” — MDN or articles explaining TDZ mechanics in detail
• “IEEE 754 floating point” — understanding why 0.1 + 0.2 !== 0.3 in any language using this standard

Variables, Types & Coercion

Variables are labeled boxes where you store data. In JavaScript there are a few rules about how you make those boxes and what kinds of things go in them. Get these basics right and a lot of “why is my code weird?” moments disappear.

Making variables: const, let, var

• const — a box you won’t reassign. Use this by default.
• let — a box you will reassign later.
• var — the old way. Avoid it; it has confusing scope rules.

const name = 'Alice'  // won't change
let count = 0         // will change: count = count + 1

The kinds of values

Most values you’ll use fall into a few simple types:

(There are two more — symbol and bigint — but you’ll rarely touch them early on.) Everything else — arrays, objects, functions — is an object.

Checking a type with typeof

typeof "hi"   // "string"
typeof 42     // "number"
typeof true   // "boolean"
typeof null   // "object"  ← a famous old bug!

Comparing: always use ===

There are two ways to compare, and one is safer:

• === checks type and value, with no surprises. Use this.
• == tries to convert types first, which leads to weird results:

0 == false      // true  😬
"" == false     // true  😬
0 === false     // false ✅ (a number is not a boolean)

Rule: use === unless you have a specific reason not to.

Truthy and falsy

In an if, every value counts as either “truthy” or “falsy.” There are exactly six falsy values — memorize these:

false, 0, "" (empty string), null, undefined, NaN

Everything else is truthy — including [] and {} (empty array and object are truthy!).

function greet(name) {
  const who = name || 'stranger'  // if name is falsy, use 'stranger'
  console.log(`Hello, ${who}`)
}

In one sentence

Use const by default (let when you’ll reassign), always compare with ===, and remember the six falsy values so your if statements behave.

Want to go deeper?

Switch to Expert mode above for the temporal dead zone, all seven primitives, bigint/symbol, and how the || and && operators return actual values.