typeof操作符的局限性包括：typeof null返回”object”这一历史bug，且无法区分对象的具体类型，对数组、日期、正则等均返回”object”；2. 选择instanceof还是object.prototype.tostring.call()应根据场景：instanceof适用于判断自定义类实例及继承关系，但不适用于原始类型且在跨全局环境时可能失效，而object.prototype.tostring.call()能可靠识别内置对象类型、null和undefined，且跨环境安全；3. 复杂数据类型的判断最佳实践是：使用array.isarray()判断数组，因其可靠且语义明确；判断函数通常用typeof，更严谨时可用object.prototype.tostring.call()区分异步或生成器函数；判断null和undefined应直接使用===，或用== null同时匹配两者；判断nan必须使用number.isnan()以避免类型转换陷阱。综上，应根据数据类型和场景选择最合适的判断方法，综合运用各类工具以确保准确性。
JavaScript中判断数据类型，其实没有一个“一招鲜”的万能方法，因为不同的数据类型，甚至同类型数据在不同场景下，都有其独特的判断逻辑和最佳实践。理解它们的异同和局限性，才是关键。我们通常会用到
typeof
、
instanceof
、
Object.prototype.toString.call()
，以及一些针对特定数据类型的辅助函数。
解决方案
在JavaScript的世界里，数据类型判断是个常青树的话题。说实话，这玩意儿看似简单，但真要搞清楚，还挺有意思的。我们通常会根据需要，选择不同的“工具”。
最基础的当然是
typeof
操作符。它能快速告诉你一个值是
string
、
number
、
boolean
、
symbol
、
bigint
、
undefined
，以及
function
。对于这些原始类型和函数，
typeof
基本是你的首选，因为它既快又直接。
console.log(typeof "hello"); // "string"console.log(typeof 123); // "number"console.log(typeof true); // "boolean"console.log(typeof Symbol('id')); // "symbol"console.log(typeof 10n); // "bigint"console.log(typeof undefined); // "undefined"console.log(typeof function(){}); // "function"
但当涉及到对象类型时，
typeof
就开始“糊弄”你了。除了函数，所有的对象，包括数组、日期、正则表达式、以及我们自己创建的对象，
typeof
一律返回
"object"
。更让人头疼的是，
typeof null
也返回
"object"
，这算是个历史遗留问题，一个著名的bug。
这时候，
instanceof
就登场了。它主要用来判断一个对象是否是某个构造函数的实例，或者说，它的原型链上是否存在某个构造函数的
prototype
。这对于我们自定义的类或者内置的构造函数（比如
Array
、
Date
）来说，非常有用。
class MyClass {}const myInstance = new MyClass();console.log(myInstance instanceof MyClass); // trueconst arr = [1, 2, 3];console.log(arr instanceof Array); // trueconsole.log(new Date() instanceof Date); // true
然而，
instanceof
也有自己的脾气。它不能判断原始类型，而且在多全局环境（比如iframe）下，由于原型链不共享，
instanceof
可能会失效。
为了更精确地识别内置对象类型，我们通常会祭出
Object.prototype.toString.call()
这个“大杀器”。它会返回一个形如
"[object Type]"
的字符串，其中
Type
就是该对象的具体类型。这是判断数组、日期、正则表达式等内置对象最可靠的方法。
console.log(Object.prototype.toString.call([])); // "[object Array]"console.log(Object.prototype.toString.call(new Date())); // "[object Date]"console.log(Object.prototype.toString.call(/s/)); // "[object RegExp]"console.log(Object.prototype.toString.call(null)); // "[object Null]"console.log(Object.prototype.toString.call(undefined)); // "[object Undefined]"console.log(Object.prototype.toString.call(123)); // "[object Number]"console.log(Object.prototype.toString.call("hello")); // "[object String]"
此外，还有一些针对特定情况的判断：
判断是否为数组，优先使用
Array.isArray()
。判断是否为
NaN
，使用
Number.isNaN()
（ES6），而不是全局的
isNaN()
。判断
null
或
undefined
，直接用
===
。
typeof
typeof
操作符的局限性有哪些？
typeof
操作符在JavaScript数据类型判断中，确实是我们的老朋友了，用起来简单直接。但说实话，它远非完美，甚至有些“历史遗留问题”让人头疼。
首先，最常被吐槽的就是
typeof null
返回
"object"
。这真的是一个历史遗留的bug，从JavaScript诞生之初就存在，并且为了兼容性一直没有被修复。这意味着如果你想判断一个变量是不是真的对象，光靠
typeof
是不够的，你还得额外检查它是不是
null
。比如：
let myVar = null;console.log(typeof myVar); // 输出 "object"if (myVar !== null && typeof myVar === 'object') { console.log("这是一个非null的对象");} else { console.log("要么是null，要么不是对象");}
其次，对于所有非函数的对象类型，
typeof
都会统一返回
"object"
。这意味着你无法通过
typeof
来区分一个数组、一个日期对象、一个正则表达式，或者一个普通的字面量对象。它们在
typeof
眼里都是“对象”。
console.log(typeof []); // "object"console.log(typeof {}); // "object"console.log(typeof new Date()); // "object"console.log(typeof /abc/); // "object"
这种“一刀切”的判断方式，在需要精确识别特定内置对象类型时，就显得力不从心了。比如，你可能需要判断一个传入的参数是不是数组，如果只用
typeof
，你只会知道它是个“对象”，而无法确定是不是数组。
总结一下，
typeof
非常适合判断原始数据类型（
string
,
number
,
boolean
,
symbol
,
bigint
,
undefined
）和函数。但一旦涉及到
null
以及更具体的对象类型（如数组、日期、自定义类实例），它的能力就非常有限了，你需要结合其他方法来弥补它的不足。
instanceof
instanceof
与
Object.prototype.toString.call()
如何选择？
在JavaScript中，当
typeof
无法满足我们对对象类型细致判断的需求时，
instanceof
和
Object.prototype.toString.call()
就成了我们手中的两把利器。它们各有侧重，理解它们的差异和适用场景，能帮助我们做出更明智的选择。
instanceof
：关注原型链和继承关系
instanceof
操作符主要用来检查一个对象是否是某个构造函数的实例。它会沿着对象的原型链向上查找，看是否存在指定构造函数的
prototype
属性。简单来说，它回答的是“这个对象是不是由那个类/构造函数创建的？”或者“这个对象是不是那个类/构造函数的子类实例？”
优点：
判断自定义类实例： 对于我们自己定义的
class
或构造函数，
instanceof
是判断实例类型的最直观方式。体现继承关系： 它能正确识别继承链上的关系。比如一个子类实例，
instanceof
父类也会返回
true
。
class Animal {}class Dog extends Animal {}const puppy = new Dog();console.log(puppy instanceof Dog); // trueconsole.log(puppy instanceof Animal); // trueconsole.log(puppy instanceof Object); // true
缺点：
无法判断原始类型：
instanceof
不能用于判断原始类型的值（
string
,
number
,
boolean
等），因为它们没有原型链可供检查。跨全局环境问题： 这是个大坑。如果一个对象是在一个iframe里创建的，然后传递到主页面，由于它们处于不同的JavaScript全局环境，各自有独立的
Array
构造函数，那么
arr instanceof Array
可能会返回
false
，即使它确实是一个数组。
Object.prototype.toString.call()
：关注对象的内部
[[Class]]
属性
这个方法利用了JavaScript内部一个被称为
[[Class]]
的属性（在ES5及以前的规范中常见，ES6后被
Symbol.toStringTag
取代，但
toString
行为不变）。它返回一个表示对象类型的字符串，格式通常是
"[object Type]"
, 这里的
Type
是内置的类型名称。
优点：
识别内置类型最可靠： 它是判断
Array
、
Date
、
RegExp
、
function
等内置对象类型最可靠的方法，因为它不依赖于构造函数，而是读取对象内部的
[[Class]]
（或
Symbol.toStringTag
）属性。跨全局环境安全： 不受不同全局环境的影响，因为
toString
方法是
Object.prototype
上的，所有对象都能继承。无论数组是在哪个iframe里创建的，它的
toString
结果都是
"[object Array]"
.能判断
null
和
undefined
：
Object.prototype.toString.call(null)
返回
"[object Null]"
，
Object.prototype.toString.call(undefined)
返回
"[object Undefined]"
，这弥补了
typeof
的不足。
const iframe = document.createElement('iframe');document.body.appendChild(iframe);const iframeArray = iframe.contentWindow.Array(1, 2, 3);console.log(iframeArray instanceof Array); // 在某些浏览器/环境下可能为 falseconsole.log(Object.prototype.toString.call(iframeArray)); // "[object Array]" - 始终为 true
如何选择？
我个人在实际开发中，会这样考量：
如果我想判断一个值是不是某个自定义类的实例，或者想利用继承关系做判断，那么
instanceof
是首选，它语义清晰。如果我需要可靠地判断一个值是不是内置的特定类型（尤其是数组、日期、正则表达式等），并且担心跨全局环境的问题，那么
Object.prototype.toString.call()
是我的不二之选。比如，判断数组，我几乎总是用
Array.isArray()
（它内部就是基于
toString.call
或类似的机制），而不是
instanceof Array
。对于原始类型，直接用
typeof
。对于
null
和
undefined
，直接用
===
或
==
。
可以说，
instanceof
更像是面向对象编程中“类型检查”的工具，而
Object.prototype.toString.call()
则更像是一个“内置类型识别器”。它们各司其职，配合使用才能覆盖JavaScript数据类型判断的各种场景。
复杂数据类型（如函数、数组）的最佳判断实践是什么？
处理JavaScript中的复杂数据类型，尤其是数组和函数，判断其类型时确实需要一些“最佳实践”，因为它们不像原始类型那样，一个
typeof
就能搞定。
判断数组：
Array.isArray()
是黄金标准
当你想知道一个变量是不是数组时，最推荐、最可靠的方法是使用
Array.isArray()
。这个方法是ES5引入的，专门用来解决
typeof
无法区分数组和普通对象，以及
instanceof Array
在跨iframe等多个全局环境可能失效的问题。
const myArray = [1, 2, 3];const myObject = { a: 1, b: 2 };const iframe = document.createElement('iframe');document.body.appendChild(iframe);const iframeArray = iframe.contentWindow.Array(4, 5, 6);console.log(Array.isArray(myArray)); // trueconsole.log(Array.isArray(myObject)); // falseconsole.log(Array.isArray(iframeArray)); // true (即便在不同上下文创建的数组，它也能正确识别)
为什么不推荐其他方法判断数组？
typeof []
会返回
"object"
，无法区分。
[] instanceof Array
在大多数情况下可以，但如前所述，跨iframe时可能失效。
Object.prototype.toString.call([]) === '[object Array]'
也能判断，但
Array.isArray()
更简洁，语义更明确，且内部实现通常更优化。
判断函数：
typeof
通常足够，
Object.prototype.toString.call()
更严谨
对于函数，
typeof
操作符通常就能很好地完成任务。
function greet() {}const arrowFunc = () => {};class MyClass {} // 类也是函数的一种console.log(typeof greet); // "function"console.log(typeof arrowFunc); // "function"console.log(typeof MyClass); // "function"
这种方法简单直接，在绝大多数情况下都够用。
如果你需要一个更“万无一失”的判断，或者想区分异步函数、生成器函数等特定类型的函数，
Object.prototype.toString.call()
会更精确。
console.log(Object.prototype.toString.call(function(){})); // "[object Function]"console.log(Object.prototype.toString.call(() => {})); // "[object Function]"console.log(Object.prototype.toString.call(async function(){})); // "[object AsyncFunction]"console.log(Object.prototype.toString.call(function*(){})); // "[object GeneratorFunction]"
但说实话，日常开发中，
typeof func === 'function'
已经能满足99%的需求了。除非你有非常特殊的业务场景，需要区分具体的函数类型，否则没必要那么复杂。
判断
null
和
undefined
：直接比较
这两种特殊值，最直接的判断方式就是使用严格相等运算符
===
。
let a; // undefinedlet b = null;let c = 0;console.log(a === undefined); // trueconsole.log(b === null); // trueconsole.log(c === undefined); // falseconsole.log(c === null); // false
如果你想判断一个值是
null
还是
undefined
（即“空”值），可以使用非严格相等
== null
，它会同时匹配
null
和
undefined
。
console.log(a == null); // true (undefined == null)console.log(b == null); // true (null == null)console.log(c == null); // false
这个技巧在处理可选参数或可能缺失的值时非常方便。
判断
NaN
：
Number.isNaN()
是正道
NaN
（Not-a-Number）是一个非常特殊的数值，它甚至不等于它自己。判断一个值是不是
NaN
，不能用
=== NaN
。
过去我们常用全局的
isNaN()
函数，但它有一个坑：它会对非数字类型的值进行隐式转换，比如
isNaN('abc')
会返回
true
，因为
'abc'
转换为数字是
NaN
。
console.log(isNaN(NaN)); // trueconsole.log(isNaN('hello')); // true (坑点)console.log(isNaN(123)); // false
ES6引入了
Number.isNaN()
，它更严谨，只判断传入的值是否严格等于
NaN
，不会进行类型转换。这是判断
NaN
的最佳实践。
console.log(Number.isNaN(NaN)); // trueconsole.log(Number.isNaN('hello')); // false (正确)console.log(Number.isNaN(123)); // false
总而言之，对于复杂数据类型，我们应该根据其特性和我们想达到的精度，选择最合适的判断方法。避免“一招鲜吃遍天”的思维，理解每种方法的优缺点，才能写出健壮可靠的代码。
以上就是js怎么判断数据类型的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1517113.html
微信扫一扫 
支付宝扫一扫 
