Detailed explanation of the properties and methods of the Number object of JavaScript native objects

Syntax for creating Number objects:

Copy code The code is as follows:

var myNum = new Number(value);

var myNum = Number(value);

When Number() is used as a constructor with operator new, it returns a newly created Number object. If you do not use the new operator and call Number() as a function, it will convert its argument to a primitive number and return this value (or NaN if the conversion fails).

MAX_VALUE

The MAX_VALUE attribute is the largest number representable in JavaScript. Its approximate value is 1.7976931348623157 x 10308. The largest negative number is -MAX_VALUE.

The number larger than MAX_VALUE is Infinity. MAX_VALUE is a static property, so the calling method should be Number.MAX_VALUE.

Copy code The code is as follows:

console.log(Number.MAX_VALUE) //1.7976931348623157e 308

MIN_VALUE

The MIN_VALUE attribute is the smallest number representable in JavaScript (close to 0, but not negative). Its approximate value is 5 x 10^-324.

All numbers smaller than MIN_VALUE will be converted to 0.

MIN_VALUE is a static property, so the calling method should be Number.MIN_VALUE.

NaN

The NaN attribute is a special value that represents a non-numeric value. This attribute is used to indicate that a value is not a number. A Number object can be set to this value to indicate that it is not a numeric value.

You can use the isNaN() global function to determine whether a value is a NaN value.

Number.NaN is a special value indicating that the result of certain arithmetic operations (such as finding the square root of a negative number) is not a number. The methods parseInt() and parseFloat() return this value when the specified string cannot be parsed. For some functions that normally return valid numbers, you can also use this method and use Number.NaN to indicate its error conditions.

JavaScript outputs Number.NaN as NaN. Note that NaN is always unequal when compared to other numbers, including itself. Therefore, you cannot compare with Number.NaN to test whether a value is a number, but can only call isNaN() for comparison.

Note: The global variable NaN is the same as Number.NaN. NaN is a non-configurable and non-modifiable attribute.

Copy code The code is as follows:

console.log(parseInt("abc")); //NaN

console.log(NaN === NaN); //false

console.log(Number.NaN === NaN); //false

console.log(isNaN(NaN)); //true

console.log(isNaN(Number.NaN)); //true

NEGATIVE_INFINITY

NEGATIVE_INFINITY attribute represents a value less than -Number.MAX_VALUE. This value represents negative infinity.

JavaScript uses -Infinity when displaying NEGATIVE_INFINITY. The arithmetic behavior of this value is very similar to infinity. For example, any number multiplied by infinity still results in infinity, and any number divided by infinity results in 0.

-Infinity is equal to Number.NEGATIVE_INFINITY.

Copy code The code is as follows:

var x = (-Number.MAX_VALUE) * 2;

var y = Number.NEGATIVE_INFINITY;

console.log(x); //-Infinity

console.log(y); //-Infinity

console.log(x===y); //true

POSITIVE_INFINITY

POSITIVE_INFINITY attribute represents a value greater than Number.MAX_VALUE. This value represents positive infinity.

JavaScript uses Infinity when displaying POSITIVE_INFINITY. The arithmetic behavior of this value is very similar to infinity. For example, any number multiplied by infinity still results in infinity, and any number divided by infinity results in 0.

Infinity is equal to Number.POSITIVE_INFINITY.

The isFinite() method can determine whether the parameter is a finite number.

Copy code The code is as follows:

var x = Number.NEGATIVE_INFINITY;
var y = Number.POSITIVE_INFINITY;
var z = Infinity;
var a = "abc";
var b = 123;

console.log(isFinite(x)); //false
console.log(isFinite(y)); //false
console.log(isFinite(z)); //false
console.log(isFinite(a)); //false
console.log(isFinite(b)); //true

toString()

The toString() method converts a Number object into a string and returns the result.

NumberObject.toString(radix)

The parameter radix is optional. Specifies the base in which the number is represented, making it an integer between 2 and 36. If this parameter is omitted, base 10 is used. It is recommended to always carry this parameter to prevent misunderstandings. For example, when radix is 2, the NumberObject is converted to a string representing the binary value.

A TypeError exception is thrown when the object calling this method is not a Number.

Copy code The code is as follows:

var a = 100;

console.log(a.toString()); //100
console.log(a.toString(10)); //100
console.log(a.toString(2)); //1100100
console.log(a.toString(8)); //144
console.log(a.toString(16)); //64

toLocaleString()

The toLocaleString() method can convert a Number object into a local format string.

String representation of a number, implementation determined, formatted according to local specifications, which may affect punctuation used for decimal or thousandth separators.

A TypeError exception is thrown when the object calling this method is not a Number.

Copy code The code is as follows:

var a = 123456;

console.log(a.toLocaleString()); //123,456
console.log(a.toLocaleString("zh-Hans-CN-u-nu-hanidec")); //One, two, three, four, five, six

For more parameters, please refer to: MDN

toFixed()

The toFixed() method rounds a Number to a number with a specified number of decimal places.

NumberObject.toFixed(num)

The parameter num is required. Specifies the number of decimal places, which is a value between 0 and 20, inclusive. Some implementations can support a larger range of values. If this parameter is omitted, 0 will be used instead.

Returns the string representation of NumberObject, which does not use exponential counting and has a fixed num digits after the decimal point. The number is rounded if necessary and padded with zeros so that it reaches the specified length. If num is greater than le 21, this method simply calls NumberObject.toString(), returning a string in exponential notation.

RangeError is thrown when num is too small or too large. Values between 0 and 20 do not raise this exception. Some implementations support a larger or smaller range of values. A TypeError exception is thrown when the object calling this method is not a Number.

Copy code The code is as follows:

var n = 12345.6789;

console.log(n.toFixed()); //12346
console.log(n.toFixed(2)); //12345.68
console.log(n.toFixed(6)); //12345.678900
console.log((1.23e 20).toFixed(2)); //123000000000000000000.00
console.log((1.23e-10).toFixed(2)); //0.00

Note: Due to the processing of floating point numbers, the result displayed by the toFixed() method is not the so-called "rounding" or "rounding six to five into double", but the performance of rounding, six and five. Very confusing.

Copy code The code is as follows:

//Chrome

console.log(( 0.035 ).toFixed( 2 )); //0.04

console.log(( 0.045 ).toFixed( 2 )); //0.04

It is recommended to write your own method to replace the default behavior of toFixed(). You can refer to: Discussion on SO:

Copy code The code is as follows:

Number.prototype.toFixed = function(len){
var temp = Math.pow(10,len);
var s = Math.ceil(this * temp)
Return s/temp;
}

console.log(( 0.035 ).toFixed( 2 )); //0.04
console.log(( 0.045 ).toFixed( 2 )); //0.05

toExponential()

The toExponential() method can convert the value of the object into exponential notation.

NumberObject.toExponential(num)

The parameter num is optional. Specifies the number of decimal places in exponential notation, which is a value between 0 and 20, inclusive. Some implementations can support a larger range of values. If this argument is omitted, as many numbers as possible will be used.

Returns the string representation of NumberObject, using exponential notation, that is, there is one digit before the decimal point and num digits after the decimal point. The decimal part of the number will be rounded, padded with zeros if necessary, so that it reaches the specified length.

Copy code The code is as follows:

var num = 10000.1234;

console.log(num.toExponential()); //1.00001234e 4
console.log(num.toExponential(2)); //1.00e 4
console.log(num.toExponential(10)); //1.0000123400e 4

toPrecision()

The toPrecision() method formats a numerical value into a string in the form of a decimal number.

NumberObject.toPrecision(num)

The parameter num is optional. Used to control the precision of numbers. This parameter is a value between 1 and 21 inclusive. If this parameter is omitted, the method toString() is called instead of converting the number to a decimal value.

Copy code The code is as follows:

var num = 10000.1234;

console.log(num.toPrecision()); //10000.1234
console.log(num.toPrecision(2)); //1.0e 4
console.log(num.toPrecision(10)); //10000.12340