JavaScript 各种类型的检测方法。

  1. typeof 123 // 'number'
  2. typeof 'abc' // 'string'
  3. typeof undefined // 'undefined'
  4. typeof true // 'boolean'
  5. typeof Math.abs // 'functuon'
  6. null === null // true
  7. [] instanceof Array // true
  8. {} instanceof Object // true
  9. new Map instanceof Map // true
  10. new Set instanceof Set // true

typeof 操作符

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

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

  1. const fn = function(n){
  2.   console.log(n)
  3. }
  4. const str = 'string'
  5. const arr = [1,2,3]
  6. const obj = {
  7.    a:123,
  8.    b:456
  9. }
  10. const num = 1
  11. const b = true
  12. const n = null     
  13. const u = undefined
  15. console.log(typeof str) // string
  16. console.log(typeof arr) // object
  17. console.log(typeof obj) // object
  18. console.log(typeof num) // number
  19. console.log(typeof b) // boolean
  20. console.log(typeof n) // object null是一个空的对象
  21. console.log(typeof u) // undefined
  22. console.log(typeof fn) // function

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

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

相等与恒等

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

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

👀 toString

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

  1. /**
  2. * @description: 数据类型的检测
  3. * @param {any} data 要检测数据类型的变量
  4. * @return {string} type 返回具体的类型名称【小写】
  5. */
  6. const isTypeOf = (data) => {
  7.     return Object.prototype.toString.call(data).replace(/\[object (\w+)\]/, '$1').toLowerCase()
  8. }
  10. console.log(isTypeOf({})) // object
  11. console.log(isTypeOf([])) // array
  12. console.log(isTypeOf("ss")) // string
  13. console.log(isTypeOf(1)) // number
  14. console.log(isTypeOf(false)) // boolean
  15. console.log(isTypeOf(/w+/)) // regexp
  16. console.log(isTypeOf(null)) // null
  17. console.log(isTypeOf(undefined)) // undefined
  18. console.log(isTypeOf(Symbol("id"))) // symbol
  19. 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();