js数据类型深层挖掘数据类型一些特殊的例子做题学历不好抱怨有毛用，提高技术就行了，人家考研，靠985也不容易哈。拿

数据类型

基本数据类型：（原始数据类型）
 string 
 number     NaN/Infinity
 boolean    true/false
 null
 undefined

 symbol 创建唯一值
 bigint

 引用数据类型
  object 
      function

一些特殊的例子

console.log(typeof NaN)  // 'number'
console.log(NaN == NaN)  // false
let a = NaN
console.log(a == a)      // false

let x = 10
if(isNaN(x)) {     // 进不来
    console.log('是真的有效数字')
}

console.log(Object.is(NaN, NaN))   // true 可以理解成 === 只是对 NaN做了特殊的处理

let s = Symbol('aa')
console.log(s == s)  // true  与 NaN 不一样
console.log(Symbol('aa') == Symbol('aa'))  // false  可以理解为比地址

做题

let res = parseFloat('left:200px')
if(res === 200) {
    alert(200)
}else if(res === NaN) {   // NaN === NaN   false
    alert(NaN)
}else if(typeof res === 'number') {
    // typeof NaN === 'number'
    alert('number')
}else {
    alert('Invalid Number')
}

number

学历不好抱怨有毛用，提高技术就行了，人家考研，靠985也不容易哈。拿起键盘干就完了。

为啥分两大类数据类型？

ECStack?

GO ?

VO 谁什么？

vo(varibale object) 变量对象，

基本类型存储

基本类型都是存储在栈内存空间里面的
写var a = 100 相当于先在栈里面存一个100，再声明一个变量a指向他。

var a = 10
var b = a
b = 999
console.log(a)  // 10 值拷贝赋值

引用类型存储

引用类型不会直接存在栈中，他会开辟一个堆内存（也是计算机分配的一个空间），用来存储自己的真实内容，每个堆都有一个16进制的地址。
把16进制的地址放到栈内存中，供变量来调用。
基本类型都是按值操作的，引用类型都是按地址操作的。

var obj = {
    val: 10
}
var obj1 = obj   // 指向同一个栈内存中的值，这个变量又指向一个堆内存中的真实值
obj1.val = 999
console.log(obj.val)  // 999

指向一个新的引用对象

当重新指向之后，o1 就和之前对象没关系了。

var o = {
    val: 10
}
var o1 = o   // o o1 执行同一个堆内存空间
o1 = {       // 把 o1 重新指向
    val: 999
}
console.log(o.val)   // 10

做题

var a = b = 10 赋值

连等赋值以右侧先运算

var a = b = 10

// 相当于
b = 10
a = 10

以下这种情况说明成员访问的优先级是比等号赋值高很多的，所以先计算他。

a.x = b = 10

// 相当于 
a.x = 10
b = 10

var a = {n: 1}
var b = a
a.x = a = {n: 2}
console.log(a.x)  // undefined
console.log(b)    // {n:1,x:{n:2}}

js 对象的key

js对象的key不能是引用类型。
js对象的key可以是任意的普通类型，也可以是symbol类型。
如果key是除了string之外的类型，访问的时候也可以通过string进行访问。

var a = {}
    b = '0'
    c = 0;
a[b] = 999
a[c] = 1
console.log(a[b])

symbol 当做对象的key

var a = {}
var b = Symbol('1')
var c = Symbol('1')
a[b] = 99
a[c] = 100

console.log(a[b])  // 99

对象不能当做Key

都会被转换成字符串。[object Object]

var a = {}
var b = {
    val: 100
}
var c = {
    val: 99
}
a[b] = 1
a[c] = 10
console.log(a[b])   // 10

数组当做参数

赋值=右边是一个新的引用类型的话，就是开辟一个新的堆内存空间。如果指向原来的对象的引用那么两个变量将指向同一个堆地址。

var x = [12, 23]
function fn(y) {
    y[0] = 100
    y = [100]
    y[1] = 200
    console.log(y) // [100, 200]
}
fn(x)   
console.log(x)    // [100, 23]

作用域链

当前私有上下文代码执行时，遇到一个变量，首先在当前作用域寻找，如果找到了，就操作当前环境下的变量，如果没找到，就一直往上找，一直找到全局上下文。

数据类型转换规则

把其他类型转换为Boolean类型

!转换为 boolean 后取反。
!! 转换为 boolean 类型
Boolean(val)
五种情况的值会变成false：''、0、undefined、null、NaN、其余的都是 true。

== 两等号转换规则

两边类型一样的几个特点

{} == {} false   // 对象比较的是地址
[] == []  flase
NaN == NaN  false

两边类型不一样的转换规则
1. null == undefined // true
2. null === undefined // false
3. 剩下的null/undefined和其他的任意类型数值都不相等
4. 字符串 == 对象要把字符串转换成对象
5. 如果 == 两边数据类型不一致都是需要转换成数字再进行比较。

对象 == 布尔 （都转为数字）
对象转为数字：先局域valueOf()获得原始值，没有原始值再去 toString()，再转为数字
[] => '' => 0
console.log([] == false)

把数组转换成布尔类型后取反
console.log(![] == false)

其他类型转换为 number

console.log(Number(''))     // 0
console.log(Number('10'))   // 10
console.log(Number('10px')) // NaN
console.log(Number(true))   // 1
console.log(Number(false))  // 0
console.log(Number(null))   // 0
console.log(Number(undefined))  // NaN
console.log(Number(Symbol(10))) // 报错
console.log(Number(BigInt(10))) // 10

对象转为数字，应该先valueOf() ,没有原始值再toString变为字符串，最后把字符串转为数字

parseInt

parseInt机制：从字符串左侧第一个字符开始（忽略空白字符），查找有效数字字符串（遇到非有效数字字符停止查找，不论后面是否还有数字字符，都不再找了）把找到的有效数字字符串转为数字，如果一个都没有找到结果就是 NaN（parseFloat比他多识别一个小数点）

js数据类型深层挖掘