Meeting the Primitive Values

Question 1

Is undefined a value?

Answer 1

Yes. It yields undefined!

Question 2

what will:

let foo
console.log(foo.bar)

yield?

Answer 2

It will throw a type error. You cannot read properties of undefined - hence all the optional chaining in JS.

Question 3

What does undefined represent?

Answer 3

A missing value - normally unintentional.

Question 4

What will:

// no var assignment
console.log(foo)

yield?

Answer 4

It will yield a reference error. Variables without assignments are wires to undefined but non instantiated variables are not wires at all, they would just yield errors.

Question 5

what will:

let foo = null
console.log(foo.bar)

yield?

Answer 5

It will throw a type error. You cannot read properties of null - hence all the optional chaining in JS.

Question 6

How are null and undefined alike?

Answer 6

• There is only one value of each
• both throw errors when trying to read properties from them
• Both represent some absence of ‘value’

Question 7

What will:

typeof null

yield?

Answer 7

// Object

This is a flipping lie. Due to a bug in JS it pretends to be an object. Null is a primitive not an object. This is just a historical accident we have to live with.

Question 8

What is the main conventional difference between null and undefined?

Answer 8

Null is for explicitly or manually set empty values and undefined is for implicitly or programmatically set empty values.

Question 9

List all the primitive values:

Answer 9

Boolean
Symbol
String
Number
Bigint
Undefined
Null

Question 10

In our mental model, what does a primitive mean?

Answer 10

It means we can’t touch it and it exists outside our code. Our variable merely connect us to those flouting other-worldly values.

I.e. there are only two booleans. False and True. All variables connect to those same two values.

Question 11

Are numbers infinite in JS?

Answer 11

Nope! Simply run:

Number.MAX_VALUE

to get the max value possible in JS.

Note! BigInt is not a Number (it is its own primitive). This is a different question with that primitive.

Question 12

What will:

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

yield and why?

Answer 12

// false

console.log(0.1 + 0.2 === 0.30000000000000004);

This highlights a common issue across various programming languages.

It is called Floating Point Math.

Question 13

What do you call math where you have to figure out the decimal? i.e. console.log(0.1 + 0.2 === 0.3);

Answer 13

Floating point math.

Question 14

Does Javascript implement the same math as we use in real life?

Answer 14

No. Javascript implements floating point math which is specifically for computers. Don’t worry too much about the subtleties - it works well enough in practice.

Basically its like a scanner - it approximates the color based on a finite range of options it has available to it. It won’t be the exact same red. JS does the same thing - it approximates numbers based on the 18 quintillion numbers it has available to it. I.e. JS has limited precision.

Basically when we write 0.1 or 0.2, we don’t get exactly 0.1 and 0.2. We get the closest available numbers in JavaScript. They are almost exactly the same, but there might be a tiny difference. These tiny differences add up, which is why 0.1 + 0.2 doesn’t give us exactly the same number as writing 0.3.

Question 15

How many numbers does JS have?

Answer 15

18 quintillion.

Question 16

What special numbers does floating point math include?

Answer 16

Nan
Infinity
-Infinity
-0

They exist because you might execute an operation like:

1/0

Here are some examples:

let scale = 0;
let a = 1 / scale; // Infinity
let b = 0 / scale; // NaN
let c = -a; // -Infinity
let d = 1 / c; // -0

Question 17

Is NaN a number?

Answer 17

Yes. It’s not lying, In floating point math NaN is a numeric value which stands for ‘not a number’. It is a numeric value which means ‘invalid result’.

Question 18

What are BigInts?

Answer 18

BigInts are one of 7 Primitive values in JS. They help us work with massive integers that numbers can’t adequately represent (being finite as they are). BigInts are not finite - but computers need the power to work with big versions of them. Big ints are represented with an ‘n’ at the end of an integer like so:

9007199254740991n

Question 19

Are strings objects?

Answer 19

Nope - strings are their own primitive. One of the 7. But they do have a few built in properties such as:

‘poop’.toUpperCase()

Strings are immutable so things like

‘poop’[0] = ‘s’

can’t yield ‘soop’. It would just do nothing at all.

Question 20

How does our mental model think about strings?

Answer 20

In our universe, there is a distinct value for every conceivable string. So there is only ever one ‘poop’ and it exists all the time - out of reach but we can point to it - i.e. as a primitive we can reference it but never alter it.

Question 21

What are symbols used for?

Answer 21

Symbols serve a similar purpose to door keys: they let you hide away some information inside an object and control which parts of the code can access it.

Question 22

Can all numbers be perfectly represented in JS?

Answer 22

Nope. Floating point math means we’re restricted in accuracy. BigInts allow us to have any possible size of integer but that doesn’t help with decimals.

Question 23

Where do we have the most precision with floating point math in JS?

Answer 23

We have more precision closer to 0 and less precision further away from it.