1、类型强制转换

1.1、string强制转换为数字

可以用*1来转化为数字(实际上是调用.valueOf方法) 然后使用Number.isNaN来判断是否为NaN，或者使用 a !== a 来判断是否为NaN，因为 NaN !== NaN

  1. '32' * 1            // 32
  2. 'ds' * 1            // NaN
  3. null * 1            // 0
  4. undefined * 1       // NaN
  5. 1  * { valueOf: ()=>'3' }        // 3

常用： 也可以使用+来转化字符串为数字

  1. + '123'                // 123
  2. + 'ds'                 // NaN
  3. + ''                   // 0
  4. + null                 // 0
  5. + undefined            // NaN
  6. + { valueOf: ()=>'3' } // 3

1.2、使用Boolean过滤数组中的所有假值

我们知道JS中有一些假值：false，null，0，""，undefined，NaN，怎样把数组中的假值快速过滤呢，可以使用Boolean构造函数来进行一次转换

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

1.3、双位运算符 ~~

可以使用双位操作符来替代正数的 Math.floor( )，替代负数的Math.ceil( )。双否定位操作符的优势在于它执行相同的操作运行速度更快。

  1. Math.floor(4.9) === 4      //true
  2. // 简写为：
  3. ~~4.9 === 4                //true
  5. ~~4.5                      // 4
  6. Math.floor(4.5)            // 4
  7. Math.ceil(4.5)             // 5
  9. ~~-4.5                         // -4
  10. Math.floor(-4.5)           // -5
  11. Math.ceil(-4.5)            // -4

1.4、短路运算符

&&为取假运算，从左到右依次判断，如果遇到一个假值，就返回假值，以后不再执行，否则返回最后一个真值
||为取真运算，从左到右依次判断，如果遇到一个真值，就返回真值，以后不再执行，否则返回最后一个假值

  1. let a = a1 && a2
  2. let b = b1 || b2

1.5、取整 | 0

对一个数字| 0可以取整，负数也同样适用，num | 0

  1. 1.3 | 0         // 1
  2. -1.9 | 0        // -1

1.6、判断奇偶数 & 1

对一个数字& 1可以判断奇偶数，负数也同样适用，num & 1

  1. const num=3;
  2. !!(num & 1)                    // true
  3. !!(num % 2)                    // true

2、字符串

2.1、字符串比较时间先后

比较时间先后顺序可以使用字符串：
因为字符串比较大小是按照字符串从左到右每个字符的charCode来的，但所以特别要注意时间形式注意补0

  1. var a = "2014-08-08";
  2. var b = "2014-09-09";
  4. console.log(a>b, a<b); // false true
  5. console.log("21:00"<"09:10");  // false
  6. console.log("21:00"<"9:10");   // true   时间形式注意补0

3、数字

3.1、数字补0操作

有时候比如显示时间的时候有时候会需要把一位数字显示成两位，这时候就需要补0操作，可以使用slice和string的padStart方法

  1. const addZero1 = (num, len = 2) => (`0${num}`).slice(-len)
  2. const addZero2 = (num, len = 2) => (`${num}`).padStart( len   , '0')
  3. addZero1(3) // 03
  5. addZero2(32,4)  // 0032

4、零合并操作符 ??

零合并操作符 ?? 是一个逻辑操作符，当左侧的操作数为 null 或者 undefined 时，返回右侧操作数，否则返回左侧操作数。
空值合并操作符一般用来为常量提供默认值，保证常量不为 null 或者 undefined，以前一般使用 || 来做这件事 variable = variable || 'bar'。然而，由于 || 是一个布尔逻辑运算符，左侧的操作数会被强制转换成布尔值用于求值。任何假值（0， ''， NaN， null， undefined）都不会被返回。这导致如果你使用 0、''、NaN 作为有效值，就会出现不可预料的后果。
正因为 || 存在这样的问题，而 ?? 的出现就是解决了这些问题，?? 只会在左侧为 undefined、null 时才返回后者，?? 可以理解为是 || 的完善解决方案。

undefined || 'default' // 'default'
null || 'default'      // 'default'
false || 'default'     // 'default'
0 || 'default'         // 'default'

undefined ?? 'default' // 'default'
null ?? 'default'      // 'default'
false ?? 'default'     // 'false'
0 ?? 'default'         // 0

另外在赋值的时候，可以运用赋值运算符的简写 ??=

let a = {b: null, c: 10}
a.b ??= 20
a.c ??= 20
console.log(a)     // 输出 { b: 20, c: 10 }

5、私有方法/属性

在一个类里面可以给属性前面增加 # 私有标记的方式来标记为私有，除了属性可以被标记为私有外，getter/setter 也可以标记为私有，方法也可以标为私有。

class Person {
  getDesc(){ 
    return this.#name +' '+ this.#getAge()
  }

  #getAge(){ return this.#age } // 私有方法

  get #name(){ return 'foo' } // 私有访问器
  #age = 23                   // 私有属性
}
const a = new Person()
console.log(a.age)       // undefined 直接访问不到
console.log(a.getDesc()) // foo 23