Name the seven primitive types in JavaScript and explain what makes a value a primitive rather than an object.

## The two-bucket model At runtime every JavaScript value falls into exactly one of two buckets: it is a **primitive**, or it is an **object**. The specification calls these the language types, and there are eight of them — the seven primitive types plus `Object`. There is no third category. Arrays, functions, `Date` instances, regular expressions, `Map`, `Set`, promises and errors are all objects; they differ only in which prototype they delegate to and which internal machinery they carry. ## The roster - **string** — an immutable sequence of UTF-16 code units: `'abc'`, `"abc"`, `` `abc` ``. - **number** — one type for every ordinary numeric value, a 64-bit IEEE-754 double: `42`, `3.14`, `-0`, `Infinity`, `NaN`. - **boolean** — exactly two values, `true` and `false`. - **undefined** — the absence the *language itself* produces. - **null** — the absence a *programmer* writes deliberately. - **symbol** (ES2015) — a value guaranteed unique, created with `Symbol('label')`, usable as a property key that cannot collide with any other. - **bigint** (ES2020) — an arbitrary-precision integer written with an `n` suffix: `9007199254740993n`. That is the complete list. If a candidate offers `array`, `function`, `object` or `date` as an eighth primitive, they have merged the two buckets. ## What actually makes a value primitive Three observable properties, all of which an interviewer can probe with two lines of code. **No own state.** A primitive is just the value; it has no slots to write into. ```js let s = 'abc'; s[0] = 'X'; console.log(s); // 'abc' — the write went nowhere ``` **Immutability.** Nothing in the language mutates a primitive in place. Every string, number and bigint operation *produces a new value*: ```js let t = 'abc'; t.toUpperCase(); // returns 'ABC' console.log(t); // still 'abc' t = t.toUpperCase(); // you must rebind to keep the result ``` Be precise about the wording here: the *value* is immutable, not the *variable*. `let t` can be rebound freely; what cannot happen is the string `'abc'` itself changing. **Copy by value.** Assignment hands over the value itself, so the two names have no ongoing relationship: ```js let a = 1; let b = a; b = 2; console.log(a); // 1 ``` Objects behave differently precisely because the value being copied is a reference to a single shared thing: ```js const o = { n: 1 }; const p = o; p.n = 2; console.log(o.n); // 2 — one object, two names ``` ## Two different kinds of nothing Both `undefined` and `null` are primitives, and both mean "no value", but they come from different places. `undefined` is what the runtime supplies when it has nothing to give: a declared-but-unassigned variable, a parameter the caller omitted, a property that was never set, a function that falls off the end without `return`. `null` is never handed to you by ordinary evaluation — a programmer (or a library author) chose it to say "intentionally empty". A handful of standard-library calls do return it as a deliberate signal, for example `String.prototype.match` when the pattern does not match, and `Object.getPrototypeOf` at the end of a prototype chain. ## Why the roster is worth memorising Almost every later JavaScript question builds on it. Coercion is defined as conversions *between primitives*, and objects are converted to a primitive first before arithmetic or comparison. The mutation bugs that dominate real code all come from the object side of the split — one object, several names. And the two newest members exist because the primitive set had gaps: `symbol` gives you a property key that cannot be guessed or collided with, and `bigint` gives you integers past the range a double can represent exactly. Both are primitives in the full sense: immutable, stateless, copied by value. ## A note on how the roster grew ES5 had five primitives; ES2015 added `symbol`; ES2020 added `bigint`. If an older tutorial says "six types", it is not wrong for its edition — it is out of date. Saying "seven, and `Object` is the eighth language type" is the answer that lands today.