Data types

Values have types

Every value in JavaScript has a type: a small label that tells the language what kind of value it is and what operations make sense. The variable name is not the type. The value inside the variable is.

You already met variables in Variables: let, const & var. That lesson separated reassignment (point a variable at a new value) from mutation (change an object through an existing reference). Data types explain why that distinction matters.

If you saw Why JavaScript?, you saw "5" + 3 become "53". That happened because one value was a string and the other was a number. This lesson names those categories without going deep on any one: each type gets its own lesson soon, starting with Numbers & math next.

JavaScript values first split into two families: primitives and objects. A primitive is a value itself: 5, "Ada", true, null. You do not open it and change a part of it. If you want a different primitive, you replace it with another primitive.

Objects are different. An object can hold properties, and code can change those properties. Variables do not contain the whole object; they contain a reference to it. Copy the reference, and two variables can reach the same object.

1let a = 5;Run2let b = a;3b = 6;4console.log(a);5 6const box1 = { n: 1 };7const box2 = box1;8box2.n = 2;9console.log(box1.n);

The first half prints 5 because numbers are primitives copied by value. The second half prints 2 because both names point at one object. Later lessons, Objects & references and Memory: primitives vs objects, go deeper into references. For now, hold onto the prediction rule: primitives copy the value; object variables copy the reference.

Here is the whole pantry. Seven types are primitive: string, number, bigint, boolean, undefined, symbol, and null. The eighth type is object, which covers plain objects, arrays, dates, functions, Math, and most structured things you work with.

A few notes keep this table honest. null is listed with primitives because it is a primitive value, even though typeof null reports "object". Functions are objects, even though typeof reports "function". Arrays are objects too; JavaScript gives you Array.isArray for that specific check.

typeof is an operator: a built-in piece of JavaScript syntax that asks “what type name should I report for this value?” It returns a string such as "number" or "object".

1const value = null;2console.log(typeof value);3console.log(Array.isArray(value));

Use typeof for broad checks: string, number, bigint, boolean, undefined, symbol, function, or object. Then patch the known rough edges:

• typeof null is "object", a historical bug kept for compatibility. Check value === null first when null matters.
• typeof [] is "object". Use Array.isArray(value).
• typeof function () is "function". Functions are callable objects; this special result is useful.
• typeof NaN is "number". NaN is a special number value.

function describe(value) {
  if (typeof value === "array") {
    return "array";
  }
  return typeof value;
}

console.log(describe([1, 2]));

There is no "array" result from typeof, so this program prints "object". The fix is a specific array check:

function describe(value) {
  if (Array.isArray(value)) {
    return "array";
  }
  return typeof value;
}

console.log(describe([1, 2]));

JavaScript is dynamically typed. That means variables do not have fixed type declarations. A variable made with let can hold a number now, a string later, and a boolean after that. The type travels with the current value.

1let value = 42;Run2console.log(typeof value);3value = "forty-two";4console.log(typeof value);5value = true;6console.log(typeof value);

Dynamic typing is convenient for learning and quick scripts, but it also means you must be clear about what kind of value your code expects. TypeScript, a later lesson, adds static type checking on top of JavaScript so tools can warn you before the program runs.

Where you’ll use this

Type checks appear when code receives a value from outside: a form input, a configuration object, a saved setting, or an API response. Early lessons keep examples tiny, but professional code uses the same moves.

function describeValue(value) {
  if (Array.isArray(value)) return "array";
  if (value === null) return "null";
  return typeof value;
}

console.log(describeValue(["Ada", "Lin"]));
console.log(describeValue(null));

This function handles the two typeof traps first: arrays and null. Only then does it return the broad typeof result. The deeper lesson Checking types reliably will build this into a stronger checklist.

Common misconceptions

Every answer explains itself. For code questions, predict first, then choose.

Key takeaways

• JavaScript has eight type categories: seven primitives plus object.
• Primitives are immutable values; objects are mutable collections reached through references.
• typeof is useful, but remember null, arrays, functions, and NaN.
• Variables are dynamically typed: the current value has the type, not the variable name.
• Use Array.isArray for arrays and value === null for null.

Up next: Numbers & math.