1. Math object
1.1 Introduction
Math object is a mathematical object that provides mathematical calculations of data, such as: obtaining absolute values, rounding upwards, etc. There is no constructor, it cannot be initialized, only static properties and methods are provided.
1.2 Constructor
None: The Math object has no constructor and cannot be initialized. Only static properties and methods are provided.
1.3 Static properties
1.3.1 Math.E: constant e. Return the base number of natural logarithm: 2.718281828459045
1.3.2 Math.PI: constant π. Return the value of Pi: 3.141592653589793
1.4 Static method
1.4.1 Math.sin(value): Sine function
1.4.2 Math.cos(value): Cosine function
1.4.3 Math.tan(value): Tangent function
1.4.4 Math.asin(value): Inverse sine function
1.4.5 Math.acos(value): Inverse cosine function
1.4.6 Math.atan(value): arctangent function
1.4.7 Math.abs(value): Returns absolute value
parameter:
①value {Number | NumberStr}: a string of numbers or pure numbers.
Return value:
{Number} Returns the absolute value of the parameter. If the parameter is not a number, return NaN.
Example:
The code copy is as follows:
h.abs('123'); // => 123: Pure numeric string
Math.abs('-123'); // => 123
Math.abs(123); // => 123
Math.abs(-123); // => 123
Math.abs('123a'); // => NaN: non-pure numeric string
1.4.8 Math.ceil(value): Round up a number, not rounding
parameter:
①value {Number | NumberStr}: a string of numbers or pure numbers.
Return value:
{Number} Returns the rounded value. If the parameter is not a number, return NaN.
Example:
The code copy is as follows:
Math.ceil(2.7); // => 3
Math.ceil(2.3); // => 3:2.3 Round up and return 3
Math.ceil(-2.7); // => -2
Math.ceil(-2.3); // => -2
Math.ceil('2.7'); // => 3: Pure numeric string
Math.ceil('2.7a'); // => NaN: non-pure numeric string
1.4.9 Math.floor(value): round downwards a number, not rounding
parameter:
①value {Number | NumberStr}: a string of numbers or pure numbers.
Return value:
{Number} Returns the rounded value. If the parameter is not a number, return NaN.
Example:
The code copy is as follows:
Math.floor(2.7); // => 2
Math.floor(2.3); // => 2
Math.floor(-2.7); // => -3 : -2.7 Round down and return -3
Math.floor(-2.3); // => -3
Math.floor('2.7'); // => 2: Pure numeric string
Math.floor('2.7a'); // => NaN: non-pure numeric string
1.4.10 Math.max(value1,value2...valueN): Returns the maximum value in the parameter
parameter:
①value1,value2......valueN {Number | NumberStr}: a string of numbers or pure numbers.
Return value:
{Number} Returns the maximum value. If a parameter is not a number, return NaN.
Example:
The code copy is as follows:
Math.max(1, 2, 3, 4, 5); // => 5
Math.max(1, 2, 3, 4, '5' ); // => 5
Math.max(1, 2, 3, 4, 'a'); // => NaN
1.4.11 Math.min(value1,value2...valueN): Returns the smallest value in the parameter
parameter:
①value1,value2......valueN {Number | NumberStr}: a string of numbers or pure numbers.
Return value:
{Number} Returns the maximum value. If a parameter is not a number, return NaN.
Example:
The code copy is as follows:
Math.min(1, 2, 3, 4, 5); // => 1
Math.min('1', 2, 3, 4, 5); // => 1
Math.min(1, 2, 3, 4, 'a'); // => NaN
1.4.12 Math.pow(x,y): Returns to the y power of x
parameter:
①x {Number | NumberStr}: a string of numbers or pure numbers.
②y {Number | NumberStr}: a string of numbers or pure numbers.
Return value:
{Number} Returns to the y power of x. If a parameter is not a number, return NaN.
Example:
The code copy is as follows:
Math.pow(2, 3); // => 8:2 to the power of 3
Math.pow(3, 2); // => 9:3 to the 2nd power
Math.pow('4', 2); // => 16:4 to the 2nd power
Math.pow('2a', 2); // => NaN
1.4.13 Math.random(): Returns a pseudo-random number, greater than 0, less than 1.0
Parameters: None
Return value:
{Number} Returns a pseudo-random number, greater than 0, less than 1.0
Example:
The code copy is as follows:
Math.random(); // => 0.8982374747283757
Math.random(); // => 0.39617531932890415
Math.random(); // => 0.35413061641156673
Math.random(); // => 0.054441051790490746
1.4.14 Math.round(value): rounded and rounded
parameter:
①value {Number | NumberStr}: a string of numbers or pure numbers.
Return value:
{Integer} Returns the integer after the parameter is rounded. If the parameter is not a number, return NaN.
Example:
The code copy is as follows:
Math.round(2.5); // => 3
Math.round(2.4); // => 2
Math.round(-2.6); // => -3
Math.round(-2.5); // => -2: -2.5 rounded to -2
Math.round(-2.4); // => -2
Math.round('2.7'); // => 3: Pure numeric string
Math.round('2.7a'); // => NaN: non-pure numeric string
1.4.15 Math.sqrt(value): Returns the square root of the parameter
parameter:
①value {Number | NumberStr}: a string of numbers or pure numbers
Return value:
{Number} Returns the square root of the parameter
Example:
The code copy is as follows:
console.log( Math.sqrt(9) ); // => 3
console.log( Math.sqrt(16) ); // => 4
console.log( Math.sqrt('25') ); // => 5
console.log( Math.sqrt('a') ); // => NaN
2. Number object
2.1 Introduction
The Number object is a number object, including integers, floating point numbers, etc. in js.
2.2 Definition
The code copy is as follows:
var a = 1;
var b = 1.1;
2.3 Static properties
2.3.1 Number.MAX_VALUE: represents the largest number in JS, about 1.79e+308
2.3.2 Number.MIN_VALUE: represents the smallest number in JS, about 5e-324
2.3.3 Number.NaN: Returns NaN, representing a non-numeric value, which is different from any other number, including NaN itself. Number.isNaN() should be used to make judgments.
2.3.4 Number.NEGATIVE_INFINITY: Returns -Infinity, indicating negative infinity.
2.3.5 Number.POSITIVE_INFINITY: Returns Infinity, indicating that it is infinity. If the calculated value is greater than Number.MAX_VALUE, the Infinity will be returned.
2.4 Static method
2.4.1 Number.isInteger(value): determine whether the parameter is an integer
parameter:
①value {Number}: number
Return value:
{Boolean} Returns whether the parameter is an integer. A pure integer string also returns false.
Example:
The code copy is as follows:
Number.isInteger(1); // => true
Number.isInteger(1.1); // => false
Number.isInteger('1'); // => false : A pure integer string also returns false
Number.isInteger('1.1'); // => false
Number.isInteger('a'); // => false : Non-string returns false
2.4.2 Number.isNaN(value): determine whether the parameter is NaN
parameter:
①value {Object}: any type
Return value:
{Boolean} Returns whether the parameter is NaN.
Example:
The code copy is as follows:
Number.isNaN(NaN); // => true
Number.isNaN('NaN'); // => false :'NaN' string, not NaN
Number.isNaN(1); // => false
Number.isNaN('1'); // => false
2.4.3 Number.parseFloat(value): Convert parameters to floating point numbers
parameter:
①value {Number | NumberStr}: a string of numbers or pure numbers
Return value:
{Integer | Float} Returns integer or floating point value
Example:
The code copy is as follows:
Number.parseFloat(1); // => 1: Integer or return integer
Number.parseFloat(1.1); // => 1.1
Number.parseFloat('1aaa'); // => 1: The string is preceded by a number, only the number is returned
Number.parseFloat('1.1aaa'); // => 1.1
Number.parseFloat('a1'); // => NaN: Non-starting number, return NaN
Number.parseFloat('a'); // => NaN
2.4.4 Number.parseInt(value): Convert parameters to integers
parameter:
①value {Number | NumberStr}: a string of numbers or pure numbers
Return value:
{Integer} Returns integer value
Example:
The code copy is as follows:
Number.parseInt(1); // => 1
Number.parseInt(1.1); // => 1: Floating point number returns integer
Number.parseInt('1aaa'); // => 1: The string is preceded by a number, only the number is returned
Number.parseInt('1.1aaa'); // => 1
Number.parseInt('a1'); // => NaN: Non-starting number, return NaN
Number.parseInt('a'); // => NaN
2.5 Example method
2.5.1 toExponential(value): convert a number to exponential type, and the parameter represents the number of digits after the decimal point
parameter:
①value {Number}: represents the number of digits after the decimal point
Return value:
{String} Returns the converted exponential type string
Example:
The code copy is as follows:
(123456789).toExponential(2); // => 1.23e+8: 2 decimal places
(123456789).toExponential(5); // => 1.23457e+8: 5 decimal places
(123456789).toExponential(10); // => 1.2345678900e+8: 10 decimal places, and 0 is used to fill in the number of insufficient digits
2.5.2 toFixed(value): Convert a number to a string with a specified decimal number. If no parameters are passed, there are no decimal places. Return value is rounded
parameter:
①value {Number}: represents the number of digits after the decimal point
Return value:
{String} Returns the converted string; not enough decimal places to be filled with 0; return value is rounded value
Example:
The code copy is as follows:
console.log((1).toFixed(2)); // => 1.00
console.log((1.2).toFixed(2)); // => 1.20: Insufficient digits, fill in with 0
console.log((1.277).toFixed(2)); // => 1.28: Rounding was performed
2.5.3 toString(): Use the specified binary to convert a number into a string. No parameters are passed in, the default is decimal.
parameter:
①value {Number}: represents the number of the binary number, value range: 2 to 36
Return value:
{String} Converts a later string
Example:
The code copy is as follows:
(10).toString(); // => 10: Decimal default
(10).toString(2); // => 1010: Binary
(10).toString(10); // => 10: decimal
(10).toString(16); // => a: hexadecimal
2.6 Application scenarios
2.6.1 Addition, subtraction, multiplication and division exceptions of floating point numbers
Note: If two floating-point numbers in Js are added, subtracted, multiplied and divided, they will return the abnormal value, such as: 0.2+0.7, and return 0.899999999999999. You can use the toFixed() method to specify decimal places.
Example:
The code copy is as follows:
console.log(0.2 + 0.7); // => 0.89999999999999999999
console.log(0.7 - 0.5); // => 0.199999999999999999999999996
console.log(3.03 * 10); // => 30.2999999999999999999997
// Use the toFixed() method
console.log( (0.2 + 0.7).toFixed(2) ); // => 0.90
console.log( (0.7 - 0.5).toFixed(2) ); // => 0.20
console.log( (3.03 * 10).toFixed(2) ); // => 30.30
2.6.2 Subtraction operation
Note: When performing subtraction operations in Js, the previous and subsequent values will be converted into numeric values before performing operations. If the conversion fails, return NaN.
Example:
The code copy is as follows:
console.log('1' - 0); // => 1: Subtract 0 from a pure numeric string, which can be quickly converted to a Nubmer object
console.log( ('1' - 0).toFixed(2) ); // => 1.00: Call the instance method after quickly converting to Nubmer object
console.log('1' - 'a'); // => NaN: One party cannot convert to a Nubmer object