The Seven Primitives and One Object

Maria has done a little C. She asks what type 5 is, and what type 5.0 is. In C those are two answers, int and double, and they behave differently. In JavaScript the answer is the same word twice: number. This lesson shows the few kinds of value JavaScript has, and the edges of the one you will use most.

Every value has a type

A value's type is the kind of thing it is: a number, a piece of text, a yes or no. The type decides what an operator does with the value. 2 * 3 multiplies, while "two" * 3 has nothing sensible to do.

JavaScript has eight types. Seven of them are primitive: simple values that cannot be taken apart. The eighth, object, holds everything else.

You can ask a value for its type with typeof. It answers with the type's name, as a string. Lesson 04 is all about it; here it is one line.

console.log(typeof 42);
console.log(typeof "Zara");
console.log(typeof true);
console.log(typeof 10n);

number
string
boolean
bigint

The type belongs to the value, not to the name. A let that holds a number can hold a string after the next assignment, as the boxes below show. So every value carries one of eight types, and three of them, number, string and boolean, do most of the work.

number: one type for 5 and 5.0

JavaScript has one number type for whole numbers and decimals. 5 and 5.0 are the same value, and console.log prints both as 5.

console.log(typeof 5);
console.log(typeof 5.0);
console.log(5.0);
console.log(5.50);
console.log(7 / 2);

number
number
5
5.5
3.5

Inside the engine, every number is stored in 64 bits in a format called IEEE 754 double precision. That one choice explains three things you will meet. Division keeps the fraction, decimals are not always exact, and very large whole numbers lose their last digits.

So 5 and 5.0 are one number, and the next three sections are the consequences of storing every number as a double.

Why 0.1 + 0.2 is not 0.3

A double stores a number in binary, as a sum of halves, quarters, eighths and so on. Most decimal fractions, such as 0.1, have no exact binary form, just as 1/3 has no exact decimal form. The engine stores the nearest double instead. Usually the tiny difference stays hidden, and sometimes it shows.

console.log(0.1 + 0.2);
console.log(0.1 + 0.2 === 0.3);
console.log(0.5 + 0.25 === 0.75);
console.log(Math.abs(0.1 + 0.2 - 0.3) < 1e-9);

0.30000000000000004
false
true
true

=== asks whether two values are exactly the same, and gives true or false; Module 2 covers it fully. 0.5 and 0.25 are a half and a quarter, exact in binary, so their sum is exact. 0.1 and 0.2 are not, and their sum misses 0.3 by about 0.00000000000000006.

The last line is the fix when you compare decimals. Math.abs gives the distance from zero, so it measures how far apart the two values are. 1e-9 is 0.000000001, written in the short form for powers of ten. If the gap is smaller than that, treat the values as equal. So never test two decimals with ===; test whether they are close.

NaN and Infinity

The number type has two values that are not ordinary numbers. Both are of type number.

console.log(0 / 0);
console.log("abc" * 2);
console.log(1 / 0);
console.log(-1 / 0);
console.log(typeof NaN);
console.log(NaN + 1);

NaN
NaN
Infinity
-Infinity
number
NaN

NaN means "not a number". It is what you get from a sum with no sensible answer, such as text times two. Yes, the type of "not a number" is number; it is a number value that marks a failed calculation. Anything done with NaN gives NaN, so one bad value spreads through every sum after it.

Infinity is the result of dividing a positive number by zero, and -Infinity of a negative one. JavaScript never stops the program for a division by zero, while C stops one for whole-number division. So NaN and Infinity are how the number type reports a sum that went wrong, and the program keeps running.

Where whole numbers stop being exact

A double has room for about 15 to 17 significant digits. Every whole number up to 2⁵³ - 1, which is 9007199254740991, is stored exactly. JavaScript names that edge Number.MAX_SAFE_INTEGER.

console.log(Number.MAX_SAFE_INTEGER);
console.log(Number.MAX_SAFE_INTEGER + 1);
console.log(Number.isSafeInteger(9007199254740991));
console.log(Number.isSafeInteger(9007199254740992));
console.log(1234567890123456789);

9007199254740991
9007199254740992
true
false
1234567890123456800

Read the last line again. The program said 1234567890123456789, and it printed a number ending in 800. Past the safe edge, the engine keeps only the nearest double it can hold, so the last digits change without any message. The number line shows where whole numbers are safe, and why gaps open past the edge.

When you need exact whole numbers past the edge, JavaScript has bigint. Write an n after the digits. A bigint is a different type, and it is exact at any size.

console.log(2 ** 64);
console.log(2n ** 64n);
console.log(9007199254740993n + 1n);

18446744073709552000
18446744073709551616n
9007199254740994n

The first line is a double, rounded. The second is exact, and console.log shows the n so you can tell them apart. So whole numbers are exact up to Number.MAX_SAFE_INTEGER, and past it you either accept rounding or switch to bigint.

string and boolean

A string is text of any length, from the empty string "" to a whole book. Every string knows how many characters it has, through .length. Module 3 is all about strings.

console.log("Zara".length);
console.log("".length);
console.log(typeof "42");
console.log(5 > 3);
console.log(2 > 7);
console.log(typeof (5 > 3));

4
0
string
true
false
boolean

"42" shows digits but is a string, because of the quotes. A boolean is one of two values, true or false. You rarely type them; comparisons such as 5 > 3 produce them, and Module 4 makes decisions with them. So a string is text in quotes, and a boolean is the answer to a yes-or-no question.

undefined and null: two kinds of nothing

JavaScript has two values that mean "nothing here", and they do not mean the same thing.

let nickname;
const middleName = null;
console.log(nickname);
console.log(middleName);

undefined
null

Amara has no middle name, so her form stores null: the question was asked, and the answer is "none". A name that was declared and never given a value holds undefined. So write null yourself when "none" is the answer, and treat a surprise undefined as a sign that something was never set. Lesson 04 tracks where it comes from.

bigint, symbol and object, briefly

bigint arrived in ES2020 for exact whole numbers past the safe edge: database ids, cryptography, contest sums. You will use it once in this track's Module 2 problems, and rarely after.

symbol arrived in ES2015. A symbol is a label that is always unique, even from another symbol with the same description. Libraries and the language itself use them. You can write code for years without making one, and this track meets it in Module 16, beside iterators.

object is the type of everything that is not a primitive: a list like [1, 2, 3], a record like { name: "Zara", age: 14 }, and even a function. Modules 7 and 8 open it up. So of the eight types, you now know the five you will use from this week on.

console.log(typeof 2026);
console.log(typeof 19.99);
console.log(typeof "2026");
console.log(typeof false);
console.log(typeof undefined);

number
number
string
boolean
undefined

console.log(2.99 * 3);
console.log(299 * 3);
console.log(299 * 3 / 100);
console.log(1.99 + 2.99);
console.log((199 + 299) / 100);

8.97
897
8.97
4.98
4.98

const a = 0.1 + 0.2;
const b = 0.3;
console.log("exact:", a === b);
console.log("close:", Math.abs(a - b) < 1e-9);
console.log("gap:", Math.abs(a - b));

exact: false
close: true
gap: 5.551115123125783e-17

let reading = 36.6;
console.log(reading, typeof reading);
reading = "not taken";
console.log(reading, typeof reading);
reading = null;
console.log(reading);

36.6 number
not taken string
null

const total = 0.1 + 0.2;
console.log(total === 0.3);

console.log(10n + 1);

const orderId = 1234567890123456789;
console.log(orderId);

const age = "14";
console.log(typeof age);

console.log(Number.MAX_SAFE_INTEGER + 2);

number
string
boolean
number
bigint

const year = 2026;
const yearText = "2026";
const agreed = false;
const price = 9.99;
const bigCount = 10n;

// Print typeof each one, in the order above.

false
true

const sum = 0.1 + 0.2;

// Line 1: is sum exactly 0.3? Use ===.
// Line 2: is the distance between sum and 0.3 less than 1e-9?

Next, lesson 04 asks values what they are with typeof, and meets the answer that has been wrong since 1995.