几种类型判断的方式
1.typeof
typeof 用来检测一个变量或一个对象的数据类型。typeof 检测变量的类型范围包括：string,number,boolean,undefine,object,function,symbel,bigint8种。
let one = 'string'
let two = 1
let three = true
let four = undefined
let five = Symbol()
let six = {} // 等价于 new Object()
let seven = [] // 等价于 new Array()
let eight = null
let nine = new Set()
let ten = new Map()
let eleven = () => {}
console.log(typeof one) // 'string'
console.log(typeof two) // 'number'
console.log(typeof true) // 'boolean'
console.log(typeof four) // 'undefine'
console.log(typeof five) // 'symbol'
console.log(typeof six) // 'object'
console.log(typeof seven) // 'object'
console.log(typeof eight) // 'object'
console.log(typeof nine) // 'object'
console.log(typeof ten) // 'object'
console.log(typeof eleven) // 'function'
其实可以看出typeof最大的问题就是无法准确区分对象，数组等类型，特别是null,也被判断为对象，这就很尴尬了。其实他们确实是一个对象，因为他们都是被构造函数new出来的实例。一般如果不需要判断是对象还是数组,可以用typeof
2.Object.prototype.toString.call(推荐)
这个就没啥好说了，基本上所有类型都能判断
console.log(Object.prototype.toString.call('string')) // [object String]
console.log(Object.prototype.toString.call(1)) // [object Number]
console.log(Object.prototype.toString.call(true)) // [object Boolean]
console.log(Object.prototype.toString.call(undefined)) // [object Undefine]
console.log(Object.prototype.toString.call(Symbol())) // [object Symbol]
console.log(Object.prototype.toString.call({})) // [object Object]
console.log(Object.prototype.toString.call([])) // [object Array]
console.log(Object.prototype.toString.call(null)) // [object Null]
console.log(Object.prototype.toString.call(new Set())) // [object Set]
console.log(Object.prototype.toString.call(new Map)) // [object Map]
console.log(Object.prototype.toString.call(function(){})) // [object Function]
console.log(Object.prototype.toString.call(/\s+/)) // [object RegExp]
不过需要注意的是返回的是[Object xxxx],可以用slice方法截取一下，此外返回的类型不同与typeof,都是首字母大写的。
3.instanceOf
顾名思义，就是判断一个对象变量是否是某个构造函数的实例或间接实例，格式： 对象变量 instanceof 类名或函数名。其实一般用的比较少，主要是在面向对象中用的比较多
function People(name,age) {
this.name = name
this.age = age
}
function ChinesePeople(name,age,ski,language) {
People.call(this,name,age)
this.ski = ski
this.age = language
}
function Animal(name,age) {
this.name = name
this.age = age
}
ChinesePeople.prototype = Object.create(People.prototype)
ChinesePeople.prototype.constructor = ChinesePeople
const insOne = new ChinesePeople('张三','18','黄色','汉语')
// instanceof 执行后 返回 true 的几种条件【符合一个即可】：
// 1.对象变量.__proto__=类名或函数名.prototype。
// 2.对象变量.__proto__.__proto__...._proto__=类名或函数名.prototype。
console.log(insOne instanceof ChinesePeople) // true
console.log(insOne instanceof People) // true
console.log(insOne instanceof Animal) // false
一些附带知识点、
if括号内的类型强制转换
实际上会调用Boolean()方法进行限制转换
分为以下几种情况
- 所有Object类都会转化为true，如对象，数组
- Undefined 转化为false
- Null 转化为false
- Booleans 转化为boolean的值
- Numbers +0，-0或NaN转化为false，其他全部转化为true
- String 空字符串为false，其他全部为true
也就是说，只有'', Undefine, Null, NAN, 0,这五种才会为false
==, == 和Object.is的区别
简单说，它们的区别是相等运算符（
==）比较两个值是否相等，严格相等运算符（===）比较它们是否为“同一个值”。如果两个值不是同一类型，严格相等运算符（===）直接返回false，而相等运算符（==）会将它们转换成同一个类型，再用严格相等运算符进行比较。
比如：
- （
===）判断（推荐）
// 1.不同类型,直接为false
console.log(1 === '1') // false
console.log(1 === true) // false
console.log(1 === "true") // false
// 2.引用类型，会比较地址是否相等
console.log({} === {}) // false
console.log([] === []) // false
console.log(function () {} === function () {}) // false
var v1 = {};
var v2 = v1;
v1 === v2 // true
// 3.`NaN`与任何值都不相等（包括自身）。另外，正`0`等于负`0`。
console.log(NaN === NaN) // false
console.log(+0 === -0)// true
// `undefined`和`null`与自身严格相等。
console.log(undefined === undefined) // true
console.log(null === null) // true
console.log(undefined === null) // false
- （
==）判断(不推荐)
// 1.原始类型值
// 原始类型的值都会转换成数值再进行比较。
1 == true // true 等同于 1 === Number(true)
0 == false // true 等同于 0 === Number(false)
2 == true // false 等同于 2 === Number(true)
'true' == true // false 等同于 Number('true') === Number(true)
'' == 0 // true 等同于 Number('') === 0
'2' == 2 // true 等同于 Number('2') === 2
'3' == 2 // false 等同于 Number('3') === 2
// 2.对象与原始类型值比较
// 与原始类型的值比较时，对象转换成原始类型的值，再进行比较。
// 具体来说，先调用对象的`valueOf()`方法，如果得到原始类型的值，就按照上一小节的规则，互相比较；如果得到的还是对象，则再调用`toString()`方法，得到字符串形式，再进行比较。
// 数组与数值的比较
[1] == 1 // true
// 对象与布尔值的比较
[1] == true // true
// 3.undefined 和 null
// `undefined`和`null`只有与自身比较，或者互相比较时，才会返回`true`；与其他类型的值比较时，结果都为`false`。
undefined == undefined // true
null == null // true
undefined == null // true
false == null // false
false == undefined // false
0 == null // false
0 == undefined // false
- Object.is
它用来比较两个值是否严格相等，与严格比较运算符（===）的行为基本一致。不同之处只有两个：一是
+0不等于-0，二是NaN等于自身。
+0 === -0 //true
NaN === NaN // false
Object.is(+0, -0) // false
Object.is(NaN, NaN) // true
