JS 数据类型进行运算时的隐式转换

前言

在js中，不同的类型的数据在做运算时，会自动地对数据类型进行转换，之后再进行计算，这种类型转换称之为隐式转换。隐式转换的规则略有繁杂，这里简单做一下归纳总结。

一元运算符

非Number类型的值会被转换成Number类型，再进行运算，返回结果为Number类型。

• 正号 +

  console.log(+undefined);       // Undefined类型  输出 NaN
  			
  console.log(+null);            // Null类型       输出 0
  
  console.log(+true);            // Boolean类型    输出 1
  
  console.log(+123);             // Number类型     输出 123
  
  console.log(+"123");           // String类型     输出 123
     
  console.log(+{value:123});     // Object类型     输出 NaN
  

• 负号 -

  console.log(-undefined);       // Undefined类型  输出 NaN
  		
  console.log(-null);            // Null类型       输出 -0
  
  console.log(-true);            // Boolean类型    输出 -1
  
  console.log(-123);             // Number类型     输出 -123
  
  console.log(-"123");           // String类型     输出 -123
  
  console.log(-{value:123});     // Object类型     输出 NaN
  

算术运算符

• 一般情况，非Number类型的值都会转换程Number类型，再进行运算，返回结果为Number类型。

  console.log(undefined * undefined); // NaN * NaN = NaN
  
  console.log(null * null);           // 0 * 0 = 0
  
  console.log(true * true);           // 1 * 1 = 1
  
  console.log(2 * 3);                 // 2 * 3 = 6 
  
  console.log("2" * "3");             // 2 * 3 = 6
   
  console.log({value:2} * {value:3}); // NaN * NaN = NaN
  

• 特殊情况，String类型的加法。两个字符串相加时，会将两个字符串拼接成一个字符串。当其它类型和字符串相加时，会转换程字符串再进行字符串拼接。返回类型为String。

  console.log("1" + "2");   // "1" + "2" = "12"
  
  console.log("1" + 2);     // "1" + "2" = "12"
  
  console.log(2 + "1");     // "2" + "1" = "21"
  
  console.log("1" + true);  // "1" + "true" = "1true"
  
  console.log(true + "1");  // "true" + "1" = "true1"
  
  console.log("1" + 2 + 3); // "1" + "2" + 3 = "12" + 3 = "12" + "3" = "123"
  
  console.log(2 + 3 + "1"); // 2 + 3 + "1" = 5 + "1" = "5" + "1" = "51"
  

比较运算符

• 一般情况，非Number类型的值都会转换成Number类型，再进行比较，返回结果为Boolean类型。

  console.log(null > 1);           // 0 > 1   false
  			
  console.log(true >= 1);          // 1 >= 1  true
  
  console.log(2 < 3);              // 2 < 3   true
  
  console.log(4 > "23");          // 4 > 23   false
  

• 特殊情况，两个String类型的值会逐位比较字符的Unicode编码大小，返回结果为Boolean类型。

  console.log("4" > "23");          // U+0034(数字4) >  U+0032(数字2)                true
  			
  console.log("#" > "%");           // U+0023(#) > U+0023(%)                        false
  
  console.log("a" < "ab");          // U+0061(a) ==  U+0061(a) U+0000( ) < U+0062(b) true
  
  console.log("b" < "ac");          // U+0062(b) <  U+0061(a)                        false
  

逻辑运算符

运算时，非Boolean类型的值会被转换为Boolean类型，但返回结果并不一定是Boolean类型。

• 非 ！
  返回结果为Boolean类型

  console.log( ! true );              // ! ture        false
  
  console.log( ! undefined );         // ! false       ture
  
  console.log( ! null );				// ! false       ture
  
  console.log( ! "string" );			// ! ture        false
  
  console.log( ! 1);					// ! ture        false
  

• 与 &&
  与运算的规则是，二者都为true时，结果为true；否则返回false。与运算的返回结果就和规则有关，与运算关注false值。有false值，会返回第一个Boolean类型值为false的原值。没有false值，就返回最后一个值的原值。即，运算时转换为Boolean值，但作为返回值时为原值。

  console.log(undefined && true);    // false && true     undefined(flase)
  		
  console.log(true && null);         // true && false     null(false)
  
  console.log(true && "str");        // true && true      "str"(true)
  
  console.log(0 && false);           // false && false    0(false)
  

• 或 ||
  或运算的规则是，二者有一个为true时，结果为true；否则返回false。或运算关注true值。返回第一个Boolean类型值true值，

  console.log(false || undefined);    // false && false     undefined(flase)
  			
  console.log(false || null);         // false && false     null(false)
  
  console.log("str" || true);        // true && true       "str"(true)
  
  console.log(1|| false);             // true && false      1(true)