【JS】关于JS的一些知识点（JS基础，纯记录）

本想着记笔记里，但是笔记里没有分类，还是以文章的形式，当个人总结吧，这一篇就当作JS基础篇的记录吧，有修改的和新增的持续更新～

关于JS的一些小技巧

1:JS中toString和valueof()区别

toString():返回一个反映这个对象的字符串

valueOf():返回它相应的原始值

console.log([1,2,3].toString()); // "1,2,3"
console.log(new Date(2015,4,4).toString()); // "Mon May 04 2015 00:00:00 GMT+0800
c"
console.log(new Date(2015,4,4).valueOf()); //  "1430668800000  "

注意： Math和Error没有valueOf方法

字符串转换为数字的三种方法js
1：pasreInt()和parseFloat()方法：转换不成功的返回NaN

2：强制类型转换： Boolean(val)/Number(val)/String(val)

3: 利用js变量弱类型转换：*1 (实际上调用了.valueOf方法)，然后使用Number.isNaN来判断是否为NaN，或者使用a!==a来判断是否为NaN，因为NaN！==NaN

'32'*1  //32
'ds'*1  //NaN

也可以使用+来转化为数字,一元正号位于操作数前面，计算操作数的数值，如果操作数不是一个数值，会尝试将其转坏为一个数值，参考见 https://developer.mozilla.org...

+'123' //123
"'ds'  //NaN
+null  //0
+undefined //NaN
+{valueOf: () => '3'}  //3

2:Boolean可以过滤掉数组的所有假值

除了false,null,undefined,0,"",NaN,都是假值

const compact = arr => arr.filter(Boolean)
compact([0, 1, false, 2, '', 3, 'a', 'e' * 23, NaN, 's', 34])             // [ 1, 2, 3, 'a', 's', 34 ]

3：双位运算符

双否定位操作符的优势在于它执行相同的操作运行速度更快

Math.floor(4.9) === 4简写为 ~~4.9 === 4

注意：对于负数来说结果不同

ps: 还可以用 4.9 | 0 === 4

4：判断奇偶数

num & 1 //奇数返回，偶数返回0

5：精确到指定位数的小数2

const round = (n, decimals = 0) => Number(`${Math.round(`${n}e${decimals}`)}e-${decimals}`)
round(1.245, 2) //1.25

6：程序中所有的等于判断都要用===，除了obj.c == null这种情况

obj.c == null 等价于obj.c === undefined/null

7:变量前加两个感叹号，判断变量的值

如果值为真，首先可以排除undefined和null，根据对象类型，可以做出如下判断

数值类型：表示不是0，并且有确定含义的值（包括无穷大）

数组，对象，函数：只能表示不是undefined或null,并不能判断是否有元素和内容。

var a = undefined/null !!a === false
var b = 0   !!b === false
var c = ''  !!c === false
//  其他都为true

var d = []/{} !!d === true

作为条件表达式，不需要使用!!进行转换，JS会自动转换，!!就只将类型转换为Boolean值

if (!!value) {}  // 等价与下面
if (value) {}

原始类型和引用类型比较

1:String和Number比较，会先将String转换成Number类型

123 == '123'  //true
'' == 0  //true

2:null和undefined比较结果是true，除此之外，null、undefined和其他任何结果值的比较值都为false

null == undefined //true
null == '' //false
null == 0 //fasle
null == false //false
undefined == '' //false
undefined == 0 //false
undefined == false //false

3:当原始类型和引用类型做比较时，对象类型会依照Toprimitive规则转换为原始类型

'[object Object] == {}' //true
'1,2,3' == [1, 2, 3] //true
[] == ![] //true

关于第三个：!的优先级高于==,![]首先会被转换成false，然后根据上面第三点，false转换成Number类型0,左侧[]转化成为0，两侧比较相等。

4:如何让：a==1 && a==2 && a==3
根据拆箱转换，以及==的隐式转换，可以如下写：

const a = {
   value:[3,2,1],
   valueOf: () => {return this.value.pop(); },
} 

5:为什么0.1+0.2 !=0.3

计算机中所有的数据都是以二进制存储的，所以在计算机计算时要把数据先转换成二进制进行计算，然后把计算结果转换成十进制。

会存在精度丢失问题

0.1和0.2的二进制都是以1100无线循环的小数

0.1的二进制：
0.0001100110011001100110011001100110011001100110011001101

0.的二进制：
0.001100110011001100110011001100110011001100110011001101