JavaScript is partly an object-oriented language.
To learn JavaScript, we got to learn the object-oriented parts of JavaScript.
In this article, we’ll look at the building blocks of objects, which are primitive values.
Primitive Data Types
JavaScript has a few primitive data types.
They’re numbers, strings, booleans, undefined , null , and bigints.
Numbers are floating-point numbers and integers.
Strings are any group of characters.
Booleans are either true or false .
undefined is a value that doesn’t exist.
null represents an empty value.
Bigints are integers that end with an n and can be outside of the safe range, which is between -2 ** 53 and 2 ** 53 .
Any value that isn’t these types are objects.
Finding Out the Value Type
We can find the value of a primitive value with the typeof operator.
typeof can return 'number' . 'string' , 'boolean' , 'undefined' , 'object' or 'function' .
Numbers are one of the types that can be detected with typeof .
Number
For instance, we can write:
let n = 1;
typeof n;
and we’ll get 'number' .
Octal and Hex Numbers
Octal and hexadecimal numbers also returns 'number' .
For instance, we can write:
let n = 0o377;
typeof n;
to write an octal number and check its type.
To check a hex number, we can write:
let n = 0x00;
typeof n;
That will also return 'number' .
Binary Numbers
We can also write binary literals with the 0b prefix,.
For instance, we can write:
let n = 0b111;
Exponents
Exponents can be written with e .
For instance, we can write:
1e1
and get 10.
If we pass it to typeof , we get 'number' :
typeof 1e1
Infinity
Infinity is another kind of number.
It’s a number too big for JavaScript to handle.
Infinity is a number, so if we write:
typeof Infinity
we get 'number' .
Dividing by 0 gives us infinity. For instance, if we write:
let a = 1 / 0
then a is Infinity .
The smallest number is -Infinity .
When we have:
Infinity - Infinity
or
- Infinity + Infinity
we get NaN since they are indeterminate in their value.
But everything else gives us Infinity or -Infinity .
For instance, we can write:
Infinity - 20
we get Infinity .
If we write:
-Infinity * 3
we get -Infinity .
There’s a global isFinite function to check is a number is finite or not.
ES6 also adds the Number.isFinite to do the same check.
The difference is that the global isFinite function casts the value before it does the check.
And Number.isFinite doesn’t do that.
NaN
NaN stands for not a number.
It’s a special value that’s also a number.
If we write:
typeof NaN
we get 'number' .
When we do some arithmetic with non-number values, then we get NaN .
For example, if we have:
let a = 10 * "a"
We get NaN .
We can check if a value is NaN with the Number.isNaN method.
There’s also the global isNaN method.
The difference is that the global one does casting and the non-global one doesn’t.
So:
Number.isNaN('test')
returns false but
Number.isNaN(NaN)
returns true .
Number.isInteger is a method that checks if a value is a finite integer.
For instance, if we have:
Number.isInteger(123)
then that returns true .
But if we have:
Number.isInteger('foo')
that returns false .
It doesn’t do casting before it does the comparison.
Conclusion
There are various kinds of primitive values in JavaScript.
One of them is a number.
There’re various representations of numbers.
