Counting the
Values · II

Regular numbers lose precision past 2⁵³. BigInts fill that gap — one value for every integer in math, which means infinitely many.

let alot = 9007199254740991n; // note the trailing n
console.log(alot + 1n); // 9007199254740992n
console.log(alot + 2n); // 9007199254740993n  — no rounding!

No funny business with the rounding — ideal where precision is sacred, like money. The specification gives BigInts arbitrary precision, so conceptually there is an infinite number of them, one per mathematical integer. Count von Count could count forever and never finish. (In practice the computer's memory runs out long before eternity does.)

Three ways to write a string, one type, and a distinct value for every conceivable string — including ones nobody has typed yet.

console.log(typeof("こんにちは")); // "string"
console.log(typeof('こんにちは')); // "string"
console.log(typeof(`こんにちは`)); // "string"
console.log(typeof(''));         // "string" (empty counts)

Strings aren't objects

Strings carry built-in properties, which makes them feel object-like. They are not. The properties are special, and they are read-only — because every primitive is immutable.

let cat = 'Cheshire';
console.log(cat.length); // 8
console.log(cat[0]);    // "C"
cat[0] = 'X';            // silently ignored / throws — no effect

Symbols are a newer primitive used to hide implementation details. Their purpose is hard to explain before we cover properties, so we'll wave and move on.

let alohomora = Symbol();
console.log(typeof(alohomora)); // "symbol"

Sorry, symbols. We'll come back for you someday.

Arrays, dates, RegExps — all objects. Objects are not primitive, so they're mutable, and crucially, every {} creates a new value.

console.log(typeof({}));        // "object"
console.log(typeof([]));        // "object"
console.log(typeof(new Date())); // "object"
console.log(typeof(/\d+/));      // "object"

The primitives we toured — null, undefined, booleans, numbers, strings — all "always existed"; we only ever summon them. Objects are different. We can make more of them. Every {} literal produces a brand-new object value that never existed before. The same goes for [] and every other object literal. This is exactly what the lab demonstrates.

Do objects disappear?

We can't destroy an object. Setting junk = null doesn't necessarily destroy anything — it just re-aims a wire.

let junk = {};
junk = null; // the object may still exist; we just stopped pointing at it

JavaScript is garbage-collected: an object may eventually vanish once no wire can reach it, on no schedule you can observe. So: we can create objects, but we can't destroy them on command. Unless you're chasing a memory leak, you can mostly forget garbage collection exists.

Forget for a moment that functions are useful. Treat a function as just another kind of value — one that, like an object, is created fresh every time its expression runs.

Three loops, each running a line seven times. How many distinct values reach console.log?

A function expression is a question to the universe, answered by creating a new function value every time it runs — just like {}. Technically functions are objects (very special ones). If you can do a thing to an object, you can usually do it to a function too.

Pointing at a function vs calling it

What does this print?

let countDwarves = function() { return 7; };
let dwarves = countDwarves;
console.log(dwarves); // ?

It's the () alone that calls. Neither let nor = has anything to do with it:

let a = countDwarves;   // point a at the function value
let b = countDwarves();  // point b at the value the function RETURNS (7)

countDwarves() is itself an expression — a call expression. To answer it, JavaScript runs the function's code and hands back the returned value.

Here's the payoff: 2 or "hello" always summons the same value, but {} or function(){} always creates a different one. That distinction is the whole basis of equality — our next chapter.