JavaScript 各种类型的检测方法。

typeof 123 // 'number'
typeof 'abc' // 'string'
typeof undefined // 'undefined'
typeof true // 'boolean'
typeof Math.abs // 'functuon'
null === null // true
[] instanceof Array // true
{} instanceof Object // true
new Map instanceof Map // true
new Set instanceof Set // true

typeof 操作符

https://www.pzijun.cn/blog/1/1.1.html

因为ECMAScript的类型系统是松散的，所以需要一种手段来确定 任意变量的数据类型。 typeof 操作符就是为此而生的。对一个值使 用 typeof 操作符会返回下列字符串之一：
“undefined” 表示值未定义；
“boolean” 表示值为布尔值；
“string” 表示值为字符串；
“number” 表示值为数值；
“object” 表示值为对象（而不是函数）或 null ；
“function” 表示值为函数；
“symbol” 表示值为符号。

注意 typeof 在某些情况下返回的结果可能会让人费解，但技术 上讲还是正确的。比如，调用 typeof null 返回的 是 “object” 。这是因为特殊值 null 被认为是一个对空对象的引 用。

const fn = function(n){
  console.log(n)
}
const str = 'string'
const arr = [1,2,3]
const obj = {
   a:123,
   b:456
}
const num = 1
const b = true
const n = null     
const u = undefined
console.log(typeof str) // string
console.log(typeof arr) // object
console.log(typeof obj) // object
console.log(typeof num) // number
console.log(typeof b) // boolean
console.log(typeof n) // object null是一个空的对象
console.log(typeof u) // undefined
console.log(typeof fn) // function

严格来讲，函数在ECMAScript中被认为是对象，并不代表一种数据类型。可是，函数也有自己特殊的属性。为此，就有必要通 过 typeof 操作符来区分函数和其他对象。

|

通过上面的检测我们发现typeof检测的Array和Object的返回类型都是Object，因此用typeof是无法检测出来数组和对象的。

为此，引入了 instanceof

instanceof

相等与恒等

相等判断也是 JavaScript 的坑之一。

// 相等 | 值相等
'1' == 1 // true
// 恒等 | 值并且类型相等
'1' === 1 // false
// 这看起来没什么问题，但是 undefined == null == '' == 0 == [] == {} == false // 居然等于 true
// 所以，在 JavaScript 中尽量使用 === 恒等进行判断。

👀 Object.prototype.toString.call()

tostring 常用 最实用的检测各种类型
我们经常会把这个封装成一个函数，使用起来更加方便

/**
* @description: 数据类型的检测
* @param {any} data 要检测数据类型的变量
* @return {string} type 返回具体的类型名称【小写】
*/
const isTypeOf = (data) => {
    return Object.prototype.toString.call(data).replace(/\[object (\w+)\]/, '$1').toLowerCase()
}
console.log(isTypeOf({})) // object
console.log(isTypeOf([])) // array
console.log(isTypeOf("ss")) // string
console.log(isTypeOf(1)) // number
console.log(isTypeOf(false)) // boolean
console.log(isTypeOf(/w+/)) // regexp
console.log(isTypeOf(null)) // null
console.log(isTypeOf(undefined)) // undefined
console.log(isTypeOf(Symbol("id"))) // symbol
console.log(isTypeOf(() => { })) // function

是否字符串

export const isString = (o) => {
return Object.prototype.toString.call(o).slice(8, -1) === ‘String’
}

是否数字

export const isNumber = (o) => {
return Object.prototype.toString.call(o).slice(8, -1) === ‘Number’
}

是否boolean

export const isBoolean = (o) => {
return Object.prototype.toString.call(o).slice(8, -1) === ‘Boolean’
}

是否函数

export const isFunction = (o) => {
return Object.prototype.toString.call(o).slice(8, -1) === ‘Function’
}

是否为null

export const isNull = (o) => {
return Object.prototype.toString.call(o).slice(8, -1) === ‘Null’
}

是否undefined

export const isUndefined = (o) => {
return Object.prototype.toString.call(o).slice(8, -1) === ‘Undefined’
}

11.是否对象

export const isObj = (o) => {
return Object.prototype.toString.call(o).slice(8, -1) === ‘Object’
}

12.是否数组

export const isArray = (o) => {
return Object.prototype.toString.call(o).slice(8, -1) === ‘Array’
}

13.是否时间

export const isDate = (o) => {
return Object.prototype.toString.call(o).slice(8, -1) === ‘Date’
}

14.是否正则

export const isRegExp = (o) => {
return Object.prototype.toString.call(o).slice(8, -1) === ‘RegExp’
}

15.是否错误对象

export const isError = (o) => {
return Object.prototype.toString.call(o).slice(8, -1) === ‘Error’
}

16.是否Symbol函数

export const isSymbol = (o) => {
return Object.prototype.toString.call(o).slice(8, -1) === ‘Symbol’
}

17.是否Promise对象

export const isPromise = (o) => {
return Object.prototype.toString.call(o).slice(8, -1) === ‘Promise’
}

18.是否Set对象

export const isSet = (o) => {
return Object.prototype.toString.call(o).slice(8, -1) === ‘Set’
}
export const ua = navigator.userAgent.toLowerCase();