Introduction to mathematical operations in JavaScript_javascript skills

In JavaScript, mathematical operations can be implemented through two operations:

1. , -, *, /, % and other operators.
2. Use the calculation function of the Math object. For example, use Math.pow(2,3) to calculate 2 raised to the third power.

Unlike Java, mathematical operations in JavaScript do not throw any errors. Operations such as overflowing calculation results, dividing by 0, and taking the square root of negative numbers are all legal. The results are special values ​​in JavaScript: positive and negative Infinity (infinity), positive and negative 0, NaN (not a number):

1. Positive and negative Infinity. When the calculation result is greater than the maximum number that JavaScript can represent (Number.MAX_VALUE), the result is positive Infinity; when the calculation result is smaller than the minimum number that JavaScript can represent (-Number.MAX_VALUE), the result is negative Infinity. Mathematical operations such as , -, * and / related to Infinity follow the rules of limit calculation in advanced mathematics. The result of 1/0 is positive Infinity, and the result of -1/0 is negative Infinity.

2. Plus or minus 0. When the calculation result is positive, but less than the smallest decimal that JavaScript can represent (Number.MIN_VALUE), the result is positive 0; when the calculation result is negative, but greater than the largest negative decimal that JavaScript can represent (-Number.MIN_VALUE) , the result is negative 0. Normally, developers don't need to care about the difference between positive and negative 0.

3.NaN. For some special calculation results that cannot be expressed even with positive and negative Infinity, JavaScript uses NaN to represent it (it is worth noting that although NaN literally means "not a number", its type is number). These special calculations include:

1).0/0.
2).Infinity/Infinity.
3). Take the square root of negative numbers.
4). Perform numerical conversion operations on non-numeric strings.

For Infinity and NaN, they are not only the printed results of "infinite" and "not a number", but also the global variable names representing these two special values ​​in JavaScript. In fact, in ECMAScript 3, these two global variables can also be assigned other values; this maddening rule has been revised in ECMAScript 5, making these two global variables read-only. In addition to directly accessing the Infinity variable and NaN variable, you can also use these two special values ​​by accessing the member variables of the Number object:

1.Infinity is equivalent to Number.POSITIVE_INFINITY.
2.-Infinity is equivalent to Number.NEGATIVE_INFINITY.
3.NaN is equivalent to Number.NaN.

In JavaScript, NaN is a very interesting special value. It has a special property: it is not equal to any other value (including itself). There are two ways to determine whether a value is NaN:

1. For variable x, determine whether x!=x is true. This expression is true only if x is NaN.

2. For variable x, call the global function isNaN() in JavaScript to determine whether isNaN(x) is true. Using this method to determine NaN is actually not rigorous, because the expression isNaN(x) is true in four cases:

1).x is NaN.
2).x is a string, and the string is not a number.
3).x is an object.
4).x is undefined.

In addition to isNaN(), JavaScript has another useful global function: isFinite(). For variable a, isFinite(a) is true in the following situations:

1).a is number, but not NaN or positive or negative Infinity.
2).a is a string, but the content of the string is a non-NaN, non-positive or negative Infinity number.
3).a is null.
4).a is a boolean value.

Since non-numeric types such as null and undefined will affect the result, I personally think it is best to determine the type of the parameter before using isNaN() or isFinite().

Experiment

Copy code The code is as follows:

//Test Infinity
var a = Number.MAX_VALUE;
console.log(a*1.1);//Infinity
console.log(a*-1.1);//-Infinity
console.log(1/0);//Infinity
console.log(-1/0);//-Infinity

//Test positive/negative 0
var b = Number.MIN_VALUE;
console.log(b/2);//0
console.log(-b/2);//0

//Test NaN
console.log(0/0);//NaN
console.log(Infinity/Infinity);//NaN
console.log(Math.sqrt(-1));//NaN
console.log(parseInt("string"));//NaN

//Test Infinity comparison
console.log(Infinity === Number.POSITIVE_INFINITY);//true
console.log(-Infinity === Number.NEGATIVE_INFINITY);//true

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

//Test isNaN()
console.log(isNaN(NaN));//true
console.log(isNaN("42"));//false
console.log(isNaN("string"));//true
console.log(isNaN({}));//true
console.log(isNaN(undefined));//true
console.log(isNaN(null));//false

//Test isFinite()
console.log(isFinite(42));//true
console.log(isFinite(Infinity));//false
console.log(isFinite(NaN));//false
console.log(isFinite("29"));//true
console.log(isFinite("string"));//false
console.log(isFinite(null));//true
console.log(isFinite(undefined));//false
console.log(isFinite(true));//true
console.log(isFinite(false));//true