Data types

What it is and why it exists

JavaScript uses dynamic typing : runtime values have types, while variable names don’t. A let binding can point to a number and later point to a string. The original value hasn’t changed type; the binding now points to another value. Dynamic typing lets the same syntax handle data from forms, JSON, and library calls, but code must state its type assumptions at those boundaries.

Language values divide into objects and seven primitive values : undefined, null, Boolean, Number, BigInt, String, and Symbol. Primitive values are immutable; replacing text or changing its case produces a new string. Objects can have mutable properties, and arrays and functions are objects rather than additional language types.

Assignment and argument passing both pass values. Copying a primitive gives you that primitive value. Copying an object value gives you another reference to the same object, so two bindings can observe changes to the same properties. Explaining this as “primitives live on the stack and objects live on the heap” isn’t reliable because storage is an implementation strategy, not ECMAScript semantics.

const constrains a binding: it can’t be made to point at another value, but it doesn’t freeze an object. const order = { count: 1 } still permits changing order.count. If an API needs a read-only object contract, express that through its design, copying, or freezing; don’t infer deep immutability from const.

These types most often affect business results when code checks external input, selects operator semantics, or decides whether two values are equal. The problem usually isn’t that “JavaScript has no types.” It is that code has left the input type, conversion rule, or missing-value policy implicit.

How it works

Seven primitive types and objects

undefined often means that no value was supplied, as with a missing property or a function without an explicit return. null is an empty value used explicitly by the program. An interface decides whether the two have different domain meanings; the language only specifies that they are distinct primitive values.

Boolean has only true and false. String is a sequence of UTF-16 code units. Symbol is a primitive with unique identity that can also serve as a property key. Number uses the IEEE 754 double-precision floating-point format for ordinary integers, fractions, Infinity, and NaN.

BigInt represents arbitrary-precision integers, and its literals end in n. It is a different numeric type from Number. Most arithmetic operations reject a mixture because the runtime can’t decide whether to preserve BigInt precision or use Number’s range and fractional semantics. Before comparing or converting, decide which numeric representation the domain needs.

Object is the type of every other language value. Plain objects, arrays, dates, regular expressions, maps, sets, and functions all belong here. Separate objects have separate identities even when their properties match; two references pass strict equality only when they point to the same object.

typeof is a coarse check

typeof returns one of a fixed set of strings. It is useful for distinguishing primitive types and detecting callable values, but it isn’t a general object classifier. The table shows common results and the checks to add when you need more precision.

typeof null === "object" is compatibility behavior retained by the language. Arrays also return "object", so an array branch must use Array.isArray(value). A “non-null object” check requires at least value !== null && typeof value === "object"; after that, validate the needed properties rather than treating every object as the same kind of record.

Conversion depends on context

Type coercion is the automatic conversion an operation performs when it needs another type. Conditions and ! use Boolean conversion; most arithmetic uses numeric conversion; interpolation and String() use string conversion. Calling Boolean(), Number(), or String() explicitly selects the corresponding rules, but “explicit” doesn’t mean the result matches your domain.

Boolean conversion has a fixed set of falsy values: false, 0, -0, 0n, "", null, undefined, and NaN. Every other language value is truthy, including "0", "false", empty arrays, and empty objects. if (value) answers “what is its truth value?” It is not a substitute for “is this field present?” or “is this array empty?”

&& and || test operand truth values but return an original operand rather than a Boolean. left && right returns left when it is falsy and otherwise returns right; left || right returns left when it is truthy and otherwise returns right. ?? chooses the right side only when the left is null or undefined, so it preserves a valid 0, false, or empty string.

Numeric conversion also has results worth defending against at boundaries. Number("") and Number(" ") are both 0, and Number(null) is 0; invalid numeric text produces NaN. parseInt() parses a prefix, so parseInt("12px", 10) is 12. That suits a syntax that explicitly permits a suffix, not validation that the whole field is a decimal integer.

Operators choose the coercion path

Subtraction, multiplication, division, and remainder first convert operands to numeric values. Addition first converts objects to primitives; if either result is a String, it concatenates, and otherwise it performs numeric addition. This makes 1 + 2 + "3" equal "33", while "1" + 2 + 3 is "123", because the expression associates from left to right.

Relational comparison can’t be reduced to “convert everything to numbers” either. After both operands become primitives, two strings are compared by their UTF-16 code units; otherwise comparison takes the numeric path. As a result, "10" < "2" is true, while Number("10") < Number("2") is false.

Loose equality == uses abstract equality comparison. It may coerce operands, but it doesn’t simply “convert both sides to the same type.” For example, null == undefined is true, while loose comparisons between either one and other values are normally false. A Boolean is first converted to Number; an object compared with a primitive is first converted to a primitive. Except for an intentional value == null check that matches both nullish values, business code is usually easier to review with strict equality and explicit boundary conversion.

Equality is not one algorithm

Strict equality === doesn’t coerce. Different types are unequal, objects compare by identity, NaN is unequal to itself, and +0 equals -0. It is the default choice for most branches, but it doesn’t provide structural comparison for objects with matching content.

Object.is() uses SameValue semantics: Object.is(NaN, NaN) is true, while Object.is(+0, -0) is false. Array.prototype.includes(), Map keys, and Set members use SameValueZero . It considers NaN equal to itself and the two zeros equal. When you choose a collection or lookup API, these boundary differences directly affect whether a value is found.

Examples

The four examples inspect types, parse external configuration, observe operator coercion, and compare equality semantics. Every output shown came from running the corresponding file locally with Node 24.

Inspecting language types

This probe starts with typeof and adds dedicated checks for null and arrays. It doesn’t try to manufacture one “exact type name” for every built-in object because application code usually needs to validate behavior or fields, not trust a spoofable label.

Here, kind is an application-level classification, not a new ECMAScript type system. It deliberately answers “is this null, an array, or another typeof category?” If a function accepts only a limited structure, continue by checking own properties and their value types.

Parsing configuration at a boundary

Environment variables, URL parameters, and form fields commonly enter a program as strings. This parser accepts only the spellings in its contract, rejects partial numbers, and uses ?? to preserve an empty label.

function parseBoolean(value, field) {
  if (value === true || value === "true") return true;
  if (value === false || value === "false") return false;
  throw new TypeError(`${field} must be true or false`);
}

function parseRetries(value) {
  const text = String(value);
  if (!/^(0|[1-9]\d*)$/.test(text)) {
    throw new TypeError("retries must be a non-negative integer");
  }
  const retries = Number(text);
  if (!Number.isSafeInteger(retries)) {
    throw new RangeError("retries is outside the safe integer range");
  }
  return retries;
}

function parseOptions(raw) {
  return {
    retries: parseRetries(raw.retries),
    verbose: parseBoolean(raw.verbose, "verbose"),
    label: raw.label ?? "worker",
  };
}

console.log(parseOptions({ retries: "0", verbose: "false", label: "" }));
console.log(parseOptions({ retries: 3, verbose: true }));

{ retries: 0, verbose: false, label: '' }
{ retries: 3, verbose: true, label: 'worker' }

Number.isSafeInteger() ensures the result is a safe integer , not a Number that has already been rounded. Parsing policy is part of the interface. If the contract permits surrounding whitespace, a leading plus, or localized digits, add those rules to the expression and tests instead of asking a conversion function to guess.

Observing contextual conversion

The same string can take different paths under different operators. JSON.stringify() makes empty strings and spaces within strings visible in the output, so terminal rendering doesn’t hide the result.

const inputs = ["5", "", "false", 0, null];

for (const value of inputs) {
  console.log(JSON.stringify({
    input: value,
    boolean: Boolean(value),
    number: Number(value),
    defaultWithOr: value || "fallback",
    defaultWithNullish: value ?? "fallback",
  }));
}

console.log("5" + 2);
console.log("5" - 2);
console.log(1 + 2 + "3");

{"input":"5","boolean":true,"number":5,"defaultWithOr":"5","defaultWithNullish":"5"}
{"input":"","boolean":false,"number":0,"defaultWithOr":"fallback","defaultWithNullish":""}
{"input":"false","boolean":true,"number":null,"defaultWithOr":"false","defaultWithNullish":"false"}
{"input":0,"boolean":false,"number":0,"defaultWithOr":"fallback","defaultWithNullish":0}
{"input":null,"boolean":false,"number":0,"defaultWithOr":"fallback","defaultWithNullish":"fallback"}
52
3
33

The third line shows null for number. That isn’t because Number("false") returns null: it returns NaN, and JSON serializes a non-finite Number in an array or object as null. When diagnosing conversion, check Number.isNaN() directly instead of treating serialized text as the in-memory value.

Comparing equality and object identity

This example puts strict equality, SameValue, and SameValueZero together. The final two lines show that matching object content doesn’t imply matching object identity.

console.log(NaN === NaN);
console.log(Object.is(NaN, NaN));
console.log([NaN].includes(NaN));

console.log(+0 === -0);
console.log(Object.is(+0, -0));
console.log(new Set([+0, -0]).size);

const first = { id: 7 };
const alias = first;
const copy = { id: 7 };

console.log(first === alias);
console.log(first === copy);

false
true
true
true
false
1
true
false

If the domain considers records with the same id to represent one entity, compare validated id values directly. General deep comparison has to define cycles, prototypes, accessors, Symbol keys, and domain rules. JSON.stringify(a) === JSON.stringify(b) isn’t a reliable substitute.

Pitfalls

Treating typeof as a complete classifier

Fix: exclude null first and use Array.isArray() for arrays. Then validate required fields, property ownership, and value types from the interface rather than inferring a full shape from one coarse label.

Parsing Boolean text with Boolean()

Fix: define the accepted spellings at the boundary, such as exactly "true" and "false", and reject everything else. Use Boolean() only when the input is already a language value and its truth value is what the operation needs.

Letting || overwrite every falsy value

Fix: use ?? when missing means only null or undefined. If an empty string or zero is also missing in this domain, write a named validation condition so the business rule remains visible.

Equating successful conversion with valid input

Fix: validate the complete input syntax before conversion, then check the converted range. For integers, choose Number.isInteger() or Number.isSafeInteger() according to the domain. Avoid global isNaN(), which coerces its argument first.

Forgetting the two meanings of +

Fix: parse both sides into the same numeric type at the calculation boundary. Use a template literal when constructing a message so string intent is visible; don’t borrow addition with an empty string as a conversion tool.

Confusing value equality with object content

Fix: default to === in ordinary branches. Use Number.isNaN() for NaN, follow the documented membership semantics of a collection API, and compare defined keys or implement contract-specific structural comparison for domain objects.

Further reading

• MDN: JavaScript data types and data structures
• MDN: typeof
• MDN: Equality comparisons and sameness
• ECMAScript specification: language types and values
• ECMAScript specification: ToPrimitive