js怎么判断数据类型-js教程-PHP中文网

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()以避免类型转换陷阱。综上，应根据数据类型和场景选择最合适的判断方法，综合运用各类工具以确保准确性。

js怎么判断数据类型

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); // true

const arr = [1, 2, 3];
console.log(arr instanceof Array); // true
console.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

登录后复制

操作符在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

登录后复制

与

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);    // true
console.log(puppy instanceof Animal); // true
console.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); // 在某些浏览器/环境下可能为 false
console.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));     // true
console.log(Array.isArray(myObject));    // false
console.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; // undefined
let b = null;
let c = 0;

console.log(a === undefined); // true
console.log(b === null);      // true
console.log(c === undefined); // false
console.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));      // true
console.log(isNaN('hello'));  // true (坑点)
console.log(isNaN(123));      // false

登录后复制

ES6引入了

Number.isNaN()

登录后复制

，它更严谨，只判断传入的值是否严格等于

NaN

登录后复制

，不会进行类型转换。这是判断

NaN

登录后复制

的最佳实践。

console.log(Number.isNaN(NaN));      // true
console.log(Number.isNaN('hello'));  // false (正确)
console.log(Number.isNaN(123));      // false

登录后复制

总而言之，对于复杂数据类型，我们应该根据其特性和我们想达到的精度，选择最合适的判断方法。避免“一招鲜吃遍天”的思维，理解每种方法的优缺点，才能写出健壮可靠的代码。

以上就是js怎么判断数据类型的详细内容，更多请关注php中文网其它相关文章！

大家都在看：

JS函数如何定义函数兼容性处理_JS函数兼容性处理定义与polyfill使用方法如何优雅地提取和管理Prisma客户端扩展类型 React组件重复渲染与数据获取优化指南 Prisma Client 扩展的类型提取与模块化实践 React/JSX与TypeScript：解决自定义HTML标签的类型声明问题

js怎么判断数据类型

解决方案

typeof
登录后复制
操作符的局限性有哪些？

instanceof
登录后复制
与
Object.prototype.toString.call()
登录后复制
如何选择？

复杂数据类型（如函数、数组）的最佳判断实践是什么？

大家都在看：

js怎么判断数据类型

解决方案

typeof登录后复制 操作符的局限性有哪些？

instanceof登录后复制 与 Object.prototype.toString.call()登录后复制 如何选择？

复杂数据类型（如函数、数组）的最佳判断实践是什么？

大家都在看：

typeof
登录后复制
操作符的局限性有哪些？

instanceof
登录后复制
与
Object.prototype.toString.call()
登录后复制
如何选择？