Summary of JavaScript type conversion methods and issues that need attention (very comprehensive)_javascript skills

1. Type conversion methods and issues that should be paid attention to:
1.Convert to Boolean type:
(1) Use two NOT operations (!):
!!5 ==> true
(2) uses the Boolean constructor:
new Boolean(5) = => true
value converted to boolean type false:
0, 0, -0, NaN, "" (empty string), undefined,null
Except for the above values, other values ​​will be true, what needs special mention is :"0",new Object(),function(){}

2. converted to string type:
(1) plus the empty string "":123
　"" = " 123"
(2) Use the string constructor: new String( 123) = "123".

Conversions that require special attention: 0 ==> "0"
-0 ==> "0"
-Infinity ==>"-Infinity"
Infinity ==>" Infinity"
NaN ==> "NaN"
undefined ==> "undefined"
null ==> "null "
new Object() ==> "[object Object]"
function(){} ==> "function(){}"
3. is converted to numeric type:
(1) take the positive ( ), subtract zero ( -0), multiplied by one, (*1), divided by one (/ 1), is negative (-, this gets the opposite value).
"123" = 123
. true = 1
(2) Use constructor Number();
new Number("123") = 123
Several conversions that require special attention:
""(empty string) ==> 0
"010" ==> 10
"0x10"(16base) ==> 16
"-010" ==> -10
"-0x10" ==> NaN
undefined ==> NaN
null ==> 0
true = => 1
false ==> 0
new Object() ==> NaN
new function(){} ==> NaN

2. Implicit type conversion:
(1)Binary addition operation ( ): If two One of the operands is of type String. The two operands will be converted to type String and then added.
If there is no string type in the two operands, then the two operands will be converted to numeric types before performing the operation.
Example:
"123" 123 = "123123";
123 123 = 246
true true = 2
true undefined = NaN (because undefined is converted to numeric value NaN, all results are NaN)
true null = 1 (null converted to a number is 0)
"123 " null = "123null" (Containing strings will be converted into string addition)
"123" undefined = "123undefined" (undefined also applies)
1 2 "123" = "3123" (1 2 is the first to follow Numerical calculations)
(2)binary subtraction, multiplication and division operations (-*/):Because only numeric types have - * / operations, the two operands will be converted to numeric types before performing the operation.
"123"-123 = 0
(3)One-yuan positive ( ), negative operator (-):Taking positive or negative values ​​is a numerical operation, so the operand will be converted into a numerical type before performing the operation.
"123" = 123
-"123" = -123
"123e" = NaN
"123f" = NaN
"123e-2" = 1.23
(4)Unary non(!)Operator:The non operator needs to operate Convert the number to Boolean type.
!"123" = false
!!"123" = true
!123 = false
!!123 = true
(5) Logical operators (&&) and (||):
When is judged on both sides of && or ||, it will be converted to Boolean type for judgment,
But I discovered an interesting thing during the test.
&& operator: If an item is false, then the expression returns false, If all items are not false, then the expression returns the original value of the rightmost item.
Example:
123 && 23 && 45 returns 45, instead of what we imagined true.
So if there is 123 && 23 == true Then it should be false.
As for if(123 && 23) think it is truethat It should be to convert 23 to Boolean type.
||Operator:
versus || The test results are also different from what I imagined. || returns the first value that is not false after conversion. If Both are false, It will return the last value that is false (the value before type conversion).
Example:
123 || 23 Return 123 , instead of the imagined true.
false || null returns null, instead of the imagined false.
3. Type conversion function
1.parseFloat Convert to floating point number:
The character parsing function gets each character until it encounters a character that is not a numerical value , and then returns the value it has obtained .
A few things that need special attention:
""(empty string) ==> NaN
"123e-2" == > 1.23 ( The scientific calculation method can be recognized)
"010" ==> 10 (8The base system cannot be recognized)
"0x10"==> 0 (16base is not recognized)
"-010" ==> -10
null,undefined,true,false,new Object(),function(){} ==> NaN
2.parseIntConvert to signed integer :
is similar to parseFloat, but it will round off the decimal places ( Note that it is not rounded, but discarded completely. It is processed in the same way as Math.floor), and it can recognize octal and 16Base representation:
123e-2 == > 1
"123e-2" ==> 123
"010" == > 8
"0x10" ==> 16
"-010" == > -8
"-0x10" ==> -16
null,undefined, true,false,new Object(),function(){},-Infinity Infinity NaN ==> NaN
3.The difference between the three rounding functions :
(1) Math.ceil(): " Ceiling”, very vivid, right? Just take the smallest integer greater than or equal to the parameter.
8.7 == > 9
-8.7==> -8
(2)Math.floor(): "Floor", takes the smallest integer less than or equal to the parameter.
8.7 ==> 8
-8.7 ==> -9
(3)Math.round(): "라운드 "정수를 가져옵니다.