js基础知识及底层运行原理3

/*

思考：这么多数据类型，他们之间是怎么转换的？

@1 把其他类型转换为数字

  +number([value])按照计算机底层存储的二进制进行转换的

    + 一般用于隐士转换[数学运算 isNAN ===比较...]

    + 字符串->数字   空字符串变为0 & 字符串中只要出现非有效数字字符结果就是NAN

    + 布尔-> 数字  true变为1  false变为0

    + null 变为数字是0

    + undefined变为数字是NAN

    + Symbol-报错

    + bigint->正常转换

    + 对象遵循 Symbol.toPrimitive/valueof/toString/number

    +...

 

    + parseInt/parseFloat([value])

     + 首先会把[value]变为字符串，从字符串中左侧第一个字符开始查找，直到找到一个非有效数字为止，把找到的结果转换为数字，一个都没有找到结果就是NAN [parseFloat多识别一个小数点]

    + parseInt（[val]）.[radix]处理机制

      + [val]必须是一个字符串，如果不是，则也要默认转换为字符串

      + [radix]不设置（或者写的是零）：正常都是按照10进制处理的，如果字符串是以‘0x’开始的默认为16进制

      + 先在[val]中，找到所有符合[radix]进制的内容（从左到右查找，直到遇到不符合的为止[不论后面是否还有符合进制的，都不在查找了]），然后再把找的内容看做[radix]进制，转换为十进制

      + [radix]范围 2-36， 除了0以外（0->10/16）,不在这个范围内的，结果都是NAN

 

    + 把其他进制转换为十进制？

     + '10101' 2进制-> 10进制  ：1*2^0 +0*2^1 + 1*2^2 +0*2^3 + 1*2^4 

    + 把其他类型转换为字符串

      +规则：原始值转换是直接用引号包起来[bigint会去除n];除对象转换为字符串是比较特殊的；

      + toString[排除object.prototype.tostring{检测数据类型}]

      + 字符串/模板字符串[‘+’在js中除了数学运算还有字符串拼接{但是其他运算符一般都是数学运算}]

      +‘+’左右两边，有一边出现了字符串或者部分对象 则都是按照字符串拼接处理的

        + Symbol.toPrimitve/valueof/tostring

      +‘+’有一边出现对象：{}+10 / 10+{}

      +‘+’只有一边：+n /++n /n++

    +....

 

    @把其他类型转换为buer

      +规则：只有' 0,NAN '' undefined null ' 会变为false，其余都是转换为true

      +场景：Boolean([value]) \!![value] \ ![value] 转换为布尔类型取反 \ 条件判断  例如：if(1){}  \ A||B  A&&B 

   //把原始值转换为字符串：[value].tostring/ string([value])

   // +[value].tostring 浏览器隐式转换都是按照这个来

 

   +对象类型转换为字符串/转换为数字{v8 [webkit]底层渲染机制}

     +第一步：先检测是否存在Symbol.toPrimitive 这个属性，存在则执行这个方法获取

     +第二步：如果不存在，则继续基于 valueof方法获取原始值

     +第三步：如果valueof获取的不是原始值，则在调用tostring转换为字符串

     +第四步：如果是转换为数字，则在number一下即可

// var arr = [10, 20, 30];

// console.log(arr + 10); //"10,20,3010"

// 先看 arr[Symbol.toPrimitive] ->undefined

// 再看 arr.valueOf() ->[10,20,30] 不是原始值

// 再看 arr.toString() -> "10,20,30"

// 字符串拼接处理了

/* // 需求：我就想变为20数字

arr[Symbol.toPrimitive] = function () {

    return 10;

};

console.log(arr + 10); 

 

//var n = new Number(10);

//  n[Symbol.toPrimitive]  undefined

//  n.valueOf()  -> 10

//console.log(n + 10); //20

 

// “+”：在JS中除了数学运算，还有字符串拼接

//   @1 “+”有左右两边，其中有一边是一个字符串「或者是个对象」，这样是字符串拼接

//      排除：{}+1  认为左边{}是个代码块，和“+1”是分开的，其实我们运算的“+1”

//           ({}+1) 这就是字符串拼接了，因为这是一个整体，或者 var n={}+1，这样也是字符串拼接...

//           1+{} 这一定是字符串拼接了

//      如果出现的是对象，按照 Symbol.toPrimitiv/valueOf/toString/Number 这个顺序来处理，能走到哪一步，就按照哪一步的规则处理

//   @2 “+”只有一边

//      例如：+[value]  把[value]变为数字

//      例如：[value]+  报错

//      例如：++i  先把i累加1「数学运算」,然后再输出或者运算

//      例如：i++  先拿i原来的值进行输出或者运算，完了之后再自己累加1

/* var i = 3;

console.log(5 + (++i)); // ++i i=4   5+4 9

i = 3;

console.log(5 + (i++)); // 5+3 8  i++ i=4

console.log(i); //4 */

 

/* var i = 2;

console.log(2 + (++i) - (i++) + (i--) - (--i)); //4

// 2+(++i)  ++i i=3  2+3 5

// 5-(i++)  5-i 2  i++ i=4

// 2+(i--)  2+i 6  i-- i=3

// 6-(--i)  --i i=2  6-2 4

console.log(i); //2 */

 

/* // 阿里

// i++ i+=1 i=i+1  是否一样?

var i = '2';

i++; //数学运算中的累加1

console.log(i); //3

 

i = '2';

i += 1; //=> i=i+1  '2'+1

console.log(i); //'21' */

 

// console.log(+'10'); //10

// console.log(1 + 1); //2

// console.log(1 + '2'); //'12'

//============

// ![value] 先把[value]转换为布尔类型,然后取反

// !![value] 转换为布尔类型  等价于 Boolean([value])

/* console.log(!1); //1->true 取反 false

console.log(![]); //false

console.log(!0); //true

console.log(!![]);

if (1) {

    // 隐式转换：先把1转换为布尔类型，判断真假，决定条件是否成立

} */

 

 

      */