In the last tutorial, we learned about JavaScript numbers and how to define them. When we use the simple number at the right side of the assignment operator it will be treated as a primitive number, but if we use the JavaScript Number() object to create a number it will be treated like a Number object.
Example
<script>
let p_num = 20; // primitive number
let o_num = new Number(20); // Number object
console.log(typeof p_num); // number
console.log(typeof o_num); // object
</script>
JavaScript Number methods and properties
Primitive number values like 1, 2, 3, etc do not support methods and properties because methods and properties are part of objects and only an object variable can access them. However there built-in methods and properties associated with the JS
Number()
object, and at the background JS also makes sure that during runtime the same properties and method also available for the primitive number values. This means all the properties and methods that are defined for
Number()
object can also be accessed through primitive number values. In this JavaScript tutorial, we will learn all the major number methods that you should know.
JS Number toString() method
As the name suggests the toString() method converts the number into a string and returns it.
Example
<script>
let num = 200;
let str_num = num.toString(); // string
console.log(str_num); // 200
console.log(typeof str_num); // string
</script>
By default, the toString() method converts the number into a decimal string of base 10, but we also specify the base number as a parameter for number conversion.
<script>
let num = 200;
let binary_num = num.toString(2); // binary
let octal_num = num.toString(8); //octal
let decimal_num = num.toString(10); //decimal(default)
let hexa_num = num.toString(16); //hexa
console.log(binary_num); //11001000
console.log(octal_num); // 310
console.log(decimal_num); // 200
console.log(hexa_num); //c8
</script>
JS Number toExponential() method
The
toExponential()
method convert the number into an exponential format or notation and return it as a string. This method also accepts an integer value as an optional parameter that defines the number of characters after the decimal point.
Example
<script>
let num = 91.23;
let ex_1 = num.toExponential();
let ex_2 = num.toExponential(4);
console.log(ex_1); //9.123e+1
console.log(ex_2); //9.1230e+1
</script>
The
num.toExponential();
statement converts the
91.23
number into
9.123e+1
which is equivalent to
9.123 * 10
.
JS Number toFixed() method
The
toFixed()
method determines how many decimal point numbers should be placed after the number. Similar to the toString() and toExponential() method it also return a string.
toFixed()
method also accepts an optional parameter which default value is 0 which represents there should be no number after the decimal point and round the number if possible.
Example
<script>
let num = 91.232345;
let fix1 = num.toFixed()
let fix2 = num.toFixed(0)
let fix3 = num.toFixed(2)
let fix4 = num.toFixed(4)
console.log(fix1); //91 (string)
console.log(fix2); //91 (string)
console.log(fix3); //91.23 (string)
console.log(fix4); //91.2323 (string)
</script>
toFixed() number comes in very handy when we want to specify fix number of decimal point numbers.
JS Number toPrecision() method
The
toPrecision()
method returns a specified length of number in a string format.
Example
<script>
let num = 91.232345;
let len1 = num.toPrecision(1); // 1 digit long
let len2 = num.toPrecision(2); // 2 digit long
let len4 = num.toPrecision(4); // 4 digit long
console.log(len1); // 9e+1 = 9*10
console.log(len2); // 91
console.log(len4); // 91.23
</script>
The parameter value of
toPrecision()
must between 1 to 100, else it throw an error.
JS Number valueOf() method
The
valueOf()
method the value of the variable. It generally used to convert the Number object to a primitive number value.
Example
<script>
let o_num = new Number(92.23234)
let p_num = o_num.valueOf();
console.log(p_num); // 92.23234
console.log(typeof p_num) // number
</script>
Number conversion in JavaScript
There are three Global methods present in JavaScript that can be used to convert a value to a number data type value.
- Number()
- parseFloat()
- parseInt()
Number() Method
JavaScript provides a global method
Number()
that can convert any legal number value to a primitive number. Do not confuse the global
Number()
method with
new Number()
object both are different. The
Number()
method can be very useful when you want to convert a JavaScript number string to a number data type for arithmetic operations.
Example
<script>
console.log(Number(true)); // 1
console.log(Number(false)); //0
console.log(Number("112")); //112
console.log(Number(" 112")); //112
console.log(Number("112 ")); //112
console.log(Number("112.23")); //112.23
console.log(Number("112,234")); // NaN
console.log(Number("112 123")); //NaN
console.log(Number("112J")); // NaN
console.log(Number("112e1")); // 1120
console.log(Number(new Date("2021-02-31"))); // 1614729600000
</script>
Behind the code
The
Number()
method converts the true and false to the corresponding 1 and 0 integer values. It also converts the Date object into Unix timestamp seconds. And if the specified argument is not a legal representation of number it returns NaN.
parseInt() Method
As the name suggests the
parseInt()
method is used to convert a number-like value to a primitive whole number. It converts the specified number-like value to an integer value. It parses the value from left to right and converts the value into a number if possible. It will return NaN if the passed value is not a legal number from left to right.
Example
<script>
console.log(parseInt(true)); // NaN
console.log(parseInt(false)); // NaN
console.log(parseInt(-1)); // -1
console.log(parseInt(2.23)); // 2
console.log(parseInt("-2.32")); // -2
console.log(parseInt("2 Years")); // 2
console.log(parseInt("year 2")); // NaN
console.log(parseInt("2 10 20")); // 2
console.log(parseInt(new Date("2021-03-13"))); // NaN
</script>
Behind the code
Unlike the
Number()
method
parseInt()
method can not convert the boolean and date object into corresponding integer values so it returns NaN instead.
parseFloat() Method
The
parseFloat()
method converts the number-like value into a floating-point number. As JS does not have a dedicated data type for float the parseFloat() method converts the passed argument to the primitive number data type. If
parseFloat()
is not able to parse the value into a number, it simply returns NaN.
<script>
console.log(parseFloat(true)); // NaN
console.log(parseFloat(false)); // NaN
console.log(parseFloat(-1)); // -1
console.log(parseFloat(2.23)); // 2.32
console.log(parseFloat("-2.32")); // -2.32
console.log(parseFloat("2 Years")); // 2
console.log(parseFloat("year 2")); // NaN
console.log(parseFloat("2 10 20")); // 2
console.log(parseFloat(new Date("2021-03-13"))); // NaN
</script>
For most cases, we use
parseFloat()
method to convert a JavaScript string value to a number value, but it does not work with boolean and Date objects. So as an alternative we can also use the
Number()
method to convert a string number to a primitive number data type.
Number Properties
There are few properties that are built-in to the Number object such as
-
MAX_VALUE: Return the possible largest number. -
MIN_VALUE: Return the possible minimum number. -
POSITIVE_INFINITY: Return the Positive Infinity -
NEGETIVE_INFINITY: Return the negative Infinity -
NaN: Return the Not a Number value.
Example
<script>
console.log(Number.MAX_VALUE); // 1.7976931348623157e+308
console.log(Number.MIN_VALUE); //5e-324
console.log(Number.POSITIVE_INFINITY); //Infinity
console.log(Number.NEGATIVE_INFINITY);//-Infinity
console.log(Number.NaN); //NaN
</script>
All these above 5 properties are available for
Number
. We can not access these properties with normal variables.
Example
let a = 23; a.MAX_VALUE; //undefined
Summary
- Mostly all the methods and properties are available for both Number objects and number data types.
- toString(), toExponential() and toFixed() methods return string numeric value.
- In JavaScript to convert a string value to a number we can use either of these three global methods, Number(), parseInt(), parseFloat().
- All these three methods are not number methods these are global methods.
- Properties like MAX_VALUE, MIN_VALUE, POSITIVE_INFINITY, NEGETIVE_INFINITY and NAN can only be accessed using the Number keyword.
People are also reading: