JS类型

• 原始类型存储的是值，对象类型存储的是地址（指针）

JS原始（Primitive）类型

• boolean
• null -- (typeof null会输出object，但null不是对象，历史遗留问题)
• undefined
• number -- (浮点类型)
• string
• symbol

JS对象（Object）类型

pass

typeof vs instanceof

typeof 对于原始类型来说，除了 null 都可以显示正确的类型，对于对象来说，除了函数都会显示 object，

typeof true // 'boolean'
typeof null // 'object'
typeof undefined // 'undefined'
typeof 1 // 'number'
typeof '1' // 'string'
typeof Symbol() // 'symbol

typeof [] // 'object'
typeof {} // 'object'
typeof console.log // 'function'

instanceof内部机制是通过原型链来判断的，直接单纯通过 instanceof 来判断原始类型是不行的

const Person = function() {}
const p1 = new Person()
p1 instanceof Person // true

var str = 'hello world'
str instanceof String // false

var str1 = new String('hello world')
str1 instanceof String // true

类型转换

• 转Boolean
  在条件判断时，除了 undefined， null， false， NaN， ''， 0， -0，其他所有值都转为 true，包括所有对象。

• 对象转原始类型
  对象在转换类型的时候，会调用内置的 [[ToPrimitive]] 函数，对于该函数来说，算法逻辑一般来说如下：
  -- 如果已经是原始类型了，那就不需要转换了
  -- 调用 x.valueOf()，如果转换为基础类型，就返回转换的值
  -- 调用 x.toString()，如果转换为基础类型，就返回转换的值
  -- 如果都没有返回原始类型，就会报错
  当然也可以重写 Symbol.toPrimitive ，该方法在转原始类型时调用优先级最高

let a = {
  valueOf() {
    return 0
  },
  toString() {
    return '1'
  },
  [Symbol.toPrimitive]() {
    return 2
  }
}
1 + a // => 3

类型判断神器 -- Object.prototype.toString.call()

Object.prototype.toString.call({})
"[object Object]"
Object.prototype.toString.call(()=>{})
"[object Function]"
Object.prototype.toString.call([])
"[object Array]"
Object.prototype.toString.call(new RegExp())
"[object RegExp]"
Object.prototype.toString.call(null)
"[object Null]"
Object.prototype.toString.call(undefined)
"[object Undefined]"
Object.prototype.toString.call(false)
"[object Boolean]"
Object.prototype.toString.call('hello')
"[object String]"
Object.prototype.toString.call(666)
"[object Number]"
Object.prototype.toString.call(Symbol())
"[object Symbol]"
Object.prototype.toString.call(new Map())
"[object Map]"
Object.prototype.toString.call(new Set())
"[object Set]"

------------------------------------------------

未完待续