null

null means intentionally nothing

null is JavaScript's value for a deliberate empty place. It does not mean “the code forgot.” It means your code, or an API you called, put a clear sign on the spot: there is no value here right now.

The previous undefined lesson focused on values JavaScript hands you when something was not supplied. This lesson focuses on the value you choose when nothing is the right answer.

The best beginner use of null is state that can be empty by design: no selected item, no logged-in session, no winner yet, or an old reference you no longer want to keep. The next replay uses all three everyday UI cases.

1let selectedItem = { id: "lesson-1", title: "Variables" };2console.log(selectedItem.title);3selectedItem = null;4console.log(selectedItem);

1let selectedItem = { id: "course", title: "JavaScript basics" };Run2let session = { user: "Ada" };3let winner = null;4 5function clearSelection() {6  selectedItem = null;7}8 9function logout() {10  session = null;11}12 13console.log(selectedItem?.title ?? "nothing selected");14clearSelection();15logout();16console.log(selectedItem === null);17console.log(session === null);18console.log(winner ?? "no winner yet");

Line 6 clears a selected item. Line 10 resets the session after logout. Line 3 starts a game value at null because there is no winner yet. The value is not a bug; it is a message to the rest of the code.

1let cachedReport = { rows: new Array(1000).fill("data") };2console.log(cachedReport.rows.length);3cachedReport = null;4console.log(cachedReport);

Setting cachedReport to null does not force garbage collection. It only means this variable no longer points at the large object. If nothing else points at that object, the engine can reclaim it later. The memory picture is in Stack & heap.

Many APIs use null as their “nothing found” answer. The DOM examples run with a tiny page that has a #save button but no #missing, no .none, and no .panel ancestor.

1const missingById = document.getElementById("missing");2const missingBySelector = document.querySelector(".none");3const button = document.querySelector("#save");4const missingAncestor = button.closest(".panel");5 6console.log(missingById);7console.log(missingBySelector);8console.log(missingAncestor);

Lines 1 and 2 search the document. Line 4 asks the button for a matching ancestor. Each miss prints null because the API deliberately reports “no matching element.”

1console.log("abc".match(/z/));2console.log(/z/.exec("abc"));3console.log(localStorage.getItem("missing"));4console.log(JSON.parse("null"));5console.log(Object.getPrototypeOf(Object.prototype));

Regular expression misses, a missing storage key, the JSON literal null, and the end of the prototype chain all produce real null values.

1const answer = prompt("Pick a name");2console.log(answer);

This prompt example is shown but not runnable in the lesson, because the result depends on pressing Cancel in a browser dialog. Cancel returns null; submitting text returns a string.

1console.log([1, 2, 3].find((n) => n > 5));2console.log(new Map([["name", "Ada"]]).get("age"));3console.log("abc".indexOf("z"));

find and Map#get use undefined. Older search APIs such as indexOf use -1. Always check the API contract.

A safe pattern is: return null from the lookup, store the result, then guard with value === null before using properties. Optional chaining and ?? can keep the code compact when a property might also be nullable.

1const users = [Run2  { id: 1, name: "Ada", photo: null },3  { id: 2, name: "Linus", photo: "linus.png" },4];5 6function findUser(id) {7  const match = users.find((user) => user.id === id);8  return match ?? null;9}10 11function describeUser(id) {12  const user = findUser(id);13  const name = user?.name ?? "Guest";14  if (user === null) {15    return name + ": no account";16  }17  const photo = user.photo ?? "default.png";18  return name + ": " + photo;19}20 21console.log(describeUser(3));

In the missing-user run, line 8 turns undefined from find into null. Line 14 checks exactly for null, so line 15 returns before any unsafe property read can happen. Try Ada to see a real user whose photo is intentionally null.

typeof null is object

typeof null returns "object". That is a famous early JavaScript bug kept for web compatibility. It does not make null a usable object. For the 1995 type-tag story, see Null inside the engine.

1const value = null;2console.log(typeof value);3console.log(value === null);4console.log(Object.prototype.toString.call(value));

Line 2 is the compatibility quirk. Line 3 is the check you should write: value === null. Line 4 uses the older object-tag helper, which can name null as [object Null] even though typeof cannot.

Reading properties of null throws

A missing property on a real object gives undefined. A property read on null is different: there is no object to read from, so JavaScript throws. V8 prints this message for the next example: TypeError: Cannot read properties of null (reading 'name').

1const profile = null;2console.log(profile.name);

1const profile = null;2if (profile === null) {3  console.log("No profile");4}5console.log(profile?.name ?? "No name");

Use the explicit check when you want the clearest beginner code. Use profile?.name ?? "No name" when you want a compact expression that stops safely and then chooses a fallback.

null in math and comparisons

null has one of JavaScript's most memorable conversion tables. Numeric conversion turns null into 0, but loose equality has a special rule that does not make null == 0 true.

1console.log(Number(null));2console.log(Number(undefined));3console.log(null + 1);4console.log(null * 3);5console.log(null == 0);6console.log(null >= 0);7console.log(null > 0);8console.log(null == undefined);9console.log(null === undefined);10console.log(null < 1);

Lines 1 through 4 are numeric conversion. Lines 5 through 10 compare values. Relational comparisons convert to numbers, so null >= 0 is true, null > 0 is false, and null < 1 is true. Loose equality only treats null like undefined.

Pick a value and an operation. The source code stays visible, the result is computed from the selected JavaScript value, and the explanation points out the rule being used.

1const value = null;2console.log(value + 1);

null in JSON and defaults

JSON keeps null because JSON has a null literal too. Defaults are different: default parameters and destructuring defaults replace undefined, not null. If you want to replace null, use an expression such as ?? or ||.

1function greet(name = "friend") {2  return `Hi, ${name}`;3}4const { photo = "avatar.png" } = { photo: null };5 6console.log(JSON.stringify({ photo: null }));7console.log(greet(null));8console.log(greet(undefined));9console.log(photo);10console.log(null ?? "fallback");11console.log(null || "fallback");

Prototype chains end at null

Every ordinary object has a prototype chain. The chain eventually reaches Object.prototype, and that object's prototype is null. That is the end of the chain. JavaScript also lets you create an object whose chain starts at null.

1const chainEnd = Object.getPrototypeOf(Object.prototype);2console.log(chainEnd);3 4const dictionary = Object.create(null);5dictionary.answer = 42;6console.log("toString" in dictionary);7console.log(dictionary.answer);

Object.create(null) makes a very plain dictionary. It has your own keys, but it does not inherit methods such as toString. That is why line 6 prints false.

Different APIs use different sentinels for “not found.” Sort these cards by the value the API gives you on a miss.

Practical uses

Use null when the empty state is part of the model. A search result can be null before anything is selected. A session can become null after logout. An API can send { "photo": null } to say the user intentionally has no photo. A DOM lookup can return null because no element matches.

The practical habit is always the same: make the intention visible, then guard before using properties. If both null and undefined should fall back, use ??. If only null is allowed, use value === null.

Common misconceptions

• “null is an object.” No. typeof null says "object" because of history; null is still a primitive.
• “Defaults replace null.” Default parameters and destructuring defaults replace undefined, not null.
• “null == 0 because Number(null) is 0.” Loose equality uses a different rule for null.
• “Reading a missing property and reading from null are the same.” A missing property gives undefined; reading from null throws.
• “Every missing API result is null.” Some APIs use undefined, -1, or an empty collection.

Key takeaways

• null is a primitive value meaning intentionally nothing.
• Your code or an API puts null there on purpose.
• Check exact null with value === null.
• typeof null is "object" for historical compatibility; do not treat null like an object.
• Reading a property of null throws; guard or use optional chaining.
• Numeric operations convert null to 0, but null == 0 is still false.
• JSON keeps null; default parameters and destructuring defaults do not replace it.

Final definition: null is JavaScript's primitive value for an intentionally empty result or state.

Up next: Booleans, null & undefined compares all three side by side. For the engine view, visit Null inside the engine.