JS判断数据类型的四种方式

JS 判断数据类型的四种方式

1. typeof 判断数据类型

• typeof 只能判断基本数据类型
• 判断复杂数据类型会返回 object

let arr = [1, 2, 3, 4, 5]
let obj = { a: 'jack', b: 'rose' }
let str = 'csdn'
let num = 1587
let bool = true
let und = undefined
let nl = null
let sy = Symbol('csdn')
let nums = NaN
function Demo() {}
console.log(typeof arr) // 返回object
console.log(typeof obj) // 返回object
console.log(typeof str) // 返回string
console.log(typeof num) // 返回number
console.log(typeof bool) // 返回boolean
console.log(typeof Demo) // 返回function
console.log(typeof und) // 返回undefined
console.log(typeof nl) // 返回object
console.log(typeof sy) // 返回symbol
console.log(typeof nums) // 返回number

2. instanceof 判断数据类型

• 语法 变量 a instanceof 数据类型 返回一个布尔值
• 只能判断对象是否存在于目标对象的原型链上，不能判断基本数据类型

let arr = [1, 2, 3, 4, 5]
let obj = { a: 'jack', b: 'rose' }
let str = 'csdn'
let num = 1587
let bool = true
let und = undefined
let nl = null
let sy = Symbol('csdn')
let nums = NaN
function Demo() {}
console.log(arr instanceof Array) //返回true
console.log(obj instanceof Object) //返回true
console.log(str instanceof String)
//返回false
//判断new String的变量则返回true,将赋值的变量判断是否为Object也会返回true
console.log(num instanceof Number) //返回false
//返回false
//判断new Number的变量则返回true,将赋值的变量判断是否为Object也会返回true
console.log(bool instanceof Boolean)
//返回false
//判断new Boolean的变量则返回true,将赋值的变量判断是否为Object也会返回true
console.log(und instanceof Object) //返回false
console.log(nl instanceof Object) //返回false
console.log(sy instanceof Symbol) //返回false
console.log(nums instanceof Number)
//返回false typeof判断NaN返回Number类型
//而instanceof判断却不等于Number
console.log(Demo instanceof Function) //返回true

3. constructor 判断数据类型

let arr = [1, 2, 3, 4, 5]
let obj = { a: 'jack', b: 'rose' }
let str = 'csdn'
let num = 1587
let bool = true
let und = undefined
let nl = null
let sy = Symbol('csdn')
let nums = NaN
function Demo() {}
let date = new Date()
let reg = /[hbc]at/gi
console.log(arr.constructor === Array) // 返回true 打印结果为 ƒ Array() { [native code] }

console.log(obj.constructor === Object) // 返回true 打印结果为 ƒ Object() { [native code] }
console.log(str.constructor === String) // 返回true 打印结果为 ƒ String() { [native code] }
console.log(num.constructor === Number) // 返回true 打印结果为 ƒ Number() { [native code] }
console.log(bool.constructor === Boolean) // 返回true 打印结果为 ƒ Boolean() { [native code] }
console.log(und.constructor === undefined) //报错
console.log(nl.constructor === null) //报错
console.log(sy.constructor === Symbol) // 返回true 打印结果为 ƒ Symbol() { [native code] }
console.log(nm.constructor === Number) // 返回true 打印结果为 ƒ Number() { [native code] }
console.log(Demo.constructor === Function) // 返回true 打印结果为 ƒ Function() { [native code] }
console.log(date.constructor === Date) // 返回true 打印结果为ƒ Date() { [native code] }
console.log(reg.constructor === RegExp) //返回true 打印结果为ƒ RegExp() { [native code] }

4. Object.prototype.toString.call 方法判断

• 最好的基本类型检测方式 Object.prototype.toString.call()
• 它可以区分 null string boolean number undefined array function object date math 数据类型

let arr = [1, 2, 3, 4, 5]
let obj = { a: 'jack', b: 'rose' }
let str = 'csdn'
let num = 1587
let bool = true
let und = undefined
let nl = null
let sy = Symbol('csdn')
let nums = NaN
function Demo() {}
let date = new Date()
let reg = /[hbc]at/gi
// 因为用Object.prototype.toString.call打印结果包裹在数组里所以要变化数组第二个的值
console.log(Object.prototype.toString.call(arr)) // 打印结果[object Array]
console.log(Object.prototype.toString.call(obj)) // 打印结果[object Object]
console.log(Object.prototype.toString.call(str)) // 打印结果[object String]
console.log(Object.prototype.toString.call(num)) // 打印结果[object Number]
console.log(Object.prototype.toString.call(bool)) // 打印结果[object Boolean]
console.log(Object.prototype.toString.call(und)) // 打印结果[object Undefined]
console.log(Object.prototype.toString.call(nl)) // 打印结果[object Null]
console.log(Object.prototype.toString.call(sy)) // 打印结果[object Symbol]
console.log(Object.prototype.toString.call(nm)) // 打印结果[object Symbol]
console.log(Object.prototype.toString.call(Demo)) // 打印结果object Function]
console.log(Object.prototype.toString.call(date)) // 打印结果[object Date]
console.log(Object.prototype.toString.call(reg)) // 打印结果[object RegExp]
// 对比方法 console.log(Object.prototype.toString.call(reg) === "[object RegExp]") 返回true