typeof与instanceof区别全解析

珍惜时间，勤奋学习！今天给大家带来《typeof与instanceof区别详解》，正文内容主要涉及到等等，如果你正在学习文章，或者是对文章有疑问，欢迎大家关注我！后面我会持续更新相关内容的，希望都能帮到正在学习的大家！

typeof 用于判断基本数据类型，返回字符串表示的类型；instanceof 用于判断对象是否是某个构造函数的实例，通过原型链查找。1. typeof 可识别基本类型如 "string"、"number"、"boolean"、"symbol"、"bigint"、"undefined"、"function" 和 "object"，但 typeof null 返回 "object" 是历史遗留问题；2. instanceof 沿原型链检查对象是否为构造函数的实例，适用于自定义类和继承场景，如判断数组或继承链中的对象；3. typeof 更适合快速判断基本类型或函数，而 instanceof 在涉及对象继承和原型链时更强大；4. 常见陷阱包括 typeof null 的误判和包装对象的混淆，多全局环境下 instanceof 可能失效，推荐使用 Array.isArray() 或 Object.prototype.toString.call() 进行更精确的类型判断。

typeof 主要用于判断基本数据类型，比如字符串、数字、布尔值，它返回一个表示类型的字符串。而 instanceof 则用来判断一个对象是否是某个构造函数的实例，它在原型链上进行查找。

typeof 运算符，说白了，就是给你一个快速、粗略的类型判断。当你把一个变量丢给它，它会吐出一个字符串，告诉你这个变量是"string"、"number"、"boolean"、"symbol"、"bigint"、"undefined"、"function"还是"object"。这里有个历史遗留的坑，typeof null 会返回 "object"，这在实际开发中确实会让人头疼，得特别留意。它对于基本数据类型判断得挺准，但一碰到对象，除了函数能识别出"function"，其他的，比如数组、日期对象、或者你自定义的任何对象，它一律都叫"object"。这也就意味着，你没法用 typeof 来区分一个数组和一个普通对象。

console.log(typeof "hello");      // "string"
console.log(typeof 123);          // "number"
console.log(typeof true);         // "boolean"
console.log(typeof undefined);    // "undefined"
console.log(typeof null);         // "object" (历史遗留问题)
console.log(typeof Symbol('id')); // "symbol"
console.log(typeof function(){}); // "function"
console.log(typeof {});           // "object"
console.log(typeof []);           // "object"

而 instanceof 呢，它的作用域更聚焦在“实例”这个概念上。它不会告诉你一个变量是什么类型，而是问你：“这个对象是不是某个构造函数创建的实例？” 它的判断依据是沿着对象的原型链向上查找，看有没有找到构造函数的 prototype 属性。如果找到了，就返回 true，否则 false。这对于你自定义的类或者通过构造函数创建的对象非常有用。

function Person(name) {
    this.name = name;
}
const alice = new Person('Alice');
const arr = [1, 2, 3];

console.log(alice instanceof Person);    // true
console.log(arr instanceof Array);       // true
console.log(arr instanceof Object);      // true (因为Array的原型链上也有Object.prototype)
console.log("hello" instanceof String);  // false (基本类型字符串不是String对象的实例)
console.log(new String("hello") instanceof String); // true (用构造函数创建的String对象)

需要注意的是，instanceof 对基本数据类型是无效的，因为它不涉及原型链继承。比如 123 instanceof Number 会是 false，因为 123 是一个原始数字值，不是 Number 构造函数创建的对象。

何时优先选择typeof？ 判断数据类型时，typeof 在很多场景下都是你的首选，因为它简单直接，性能开销也小。

具体来说，当你需要快速判断一个变量是不是原始类型，比如字符串、数字、布尔值、undefined 或 symbol 时，typeof 是最可靠且效率最高的办法。例如，你可能需要检查一个函数参数是否确实是一个数字，以便进行后续的数学运算。

function processNumber(value) {
    if (typeof value !== 'number') {
        console.error("输入必须是一个数字！");
        return;
    }
    // ... 对数字进行操作
}
processNumber(100);
processNumber("abc");

此外，如果你想确认一个变量是不是一个函数，typeof 也能直接给你答案，返回 "function"。这在需要动态调用函数或者检查回调函数是否存在时非常方便。

function executeIfFunction(callback) {
    if (typeof callback === 'function') {
        callback();
    } else {
        console.warn("提供的不是一个函数，无法执行。");
    }
}
executeIfFunction(() => console.log("我是一个函数！"));
executeIfFunction("不是函数");

所以，当你的需求是广义上的类型判断，而不是具体到某个构造函数的实例时，typeof 往往是更清晰、更少出错的选择。

为什么instanceof在处理继承和自定义对象时更强大？ 在JavaScript的世界里，对象之间的关系往往比你想象的要复杂，尤其是涉及到继承。这时候，instanceof 的优势就凸显出来了，因为它能够理解并沿着原型链进行判断。

想象一下，你定义了一个 Animal 类，然后又有一个 Dog 类继承自 Animal。如果你创建了一个 Dog 的实例，你当然希望它既能被识别为 Dog 的实例，也能被识别为 Animal 的实例。instanceof 就能做到这一点：

class Animal {
    constructor(name) {
        this.name = name;
    }
}

class Dog extends Animal {
    constructor(name, breed) {
        super(name);
        this.breed = breed;
    }
}

const myDog = new Dog('Buddy', 'Golden Retriever');

console.log(myDog instanceof Dog);    // true
console.log(myDog instanceof Animal); // true
console.log(myDog instanceof Object); // true (所有对象最终都继承自Object)

typeof 在这种场景下就无能为力了，它只会告诉你 myDog 是一个 "object"。instanceof 深入到对象的内部机制，检查 myDog 的原型链上是否存在 Dog.prototype 和 Animal.prototype，从而给出更精确、更有意义的答案。

这对于你在处理多态性或者需要根据对象的具体“血统”来执行不同逻辑时非常关键。比如，你有一个处理动物的函数，它可能需要对所有的 Animal 实例执行某个通用操作，但对 Dog 实例有额外的特定处理。instanceof 让你能够轻松地进行这种区分。

typeof null为何是'object'以及其他常见陷阱 在使用 typeof 和 instanceof 时，确实有一些不那么直观的地方，甚至可以说是一些“坑”，了解它们能帮你避免不少麻烦。

最常被提及的，就是 typeof null 的结果是 'object'。这不是一个bug，但它确实是一个历史遗留的设计缺陷，源于JavaScript最初实现时的考量。当时，值的机器表示中，null 的类型标签被错误地设置为与对象相同的位模式。为了保持向后兼容性，这个行为一直没有被修正。所以，当你需要精确判断一个值是否为 null 时，直接使用严格相等 === null 才是最稳妥的方法。

const value = null;
console.log(typeof value); // "object"
console.log(value === null); // true (正确判断null)

另一个常见的混淆点是原始类型值和它们的包装对象。比如，"hello" 是一个字符串原始值，而 new String("hello") 是一个 String 对象。typeof 会区分它们：

console.log(typeof "hello");           // "string"
console.log(typeof new String("hello")); // "object"

console.log("hello" instanceof String);           // false
console.log(new String("hello") instanceof String); // true

这说明 typeof 在这里判断的是底层数据类型或包装对象，而 instanceof 则专注于原型链。在绝大多数情况下，我们都应该使用原始类型值，避免创建包装对象，以免引入不必要的复杂性。

再一个稍微高级点的陷阱，是 instanceof 在多全局环境（比如浏览器中的 iframe）下可能会失效。因为每个 iframe 都有它自己独立的全局对象和构造函数。一个在 iframe A 中创建的数组，即使它的结构和行为都像一个数组，但在 iframe B 中用 Array 构造函数去判断它，instanceof Array 可能会返回 false，因为它们的 Array 构造函数不是同一个引用。

为了更精确地判断内置对象的类型，尤其是数组，Array.isArray() 是一个更可靠且推荐的方法。对于其他内置对象，Object.prototype.toString.call() 提供了一种非常精确的类型检测方式，它会返回一个形如 "[object Type]" 的字符串，例如 "[object Array]"、"[object Date]"、"[object Function]" 等。

const myArray = [1, 2];
console.log(Array.isArray(myArray)); // true

const myDate = new Date();
console.log(Object.prototype.toString.call(myDate)); // "[object Date]"

这些方法在处理复杂或不确定的数据类型时，能提供比 typeof 和 instanceof 更稳健的判断。

以上就是《typeof与instanceof区别全解析》的详细内容，更多关于的资料请关注golang学习网公众号！