instanceof 运算符

1. 基本用法

1.1 检查对象类型

// 基本用法
class Person {}
const person = new Person();
console.log(person instanceof Person); // true

// 检查内置类型
const arr = [];
console.log(arr instanceof Array); // true
console.log(arr instanceof Object); // true

// 检查函数类型
function test() {}
console.log(test instanceof Function); // true

1.2 继承关系检查

class Animal {}
class Dog extends Animal {}
const dog = new Dog();

console.log(dog instanceof Dog); // true
console.log(dog instanceof Animal); // true
console.log(dog instanceof Object); // true

2. 工作原理

2.1 原型链检查

class A {}
class B extends A {}
const b = new B();

// instanceof 检查原型链
console.log(b instanceof B); // true
console.log(b instanceof A); // true
console.log(b instanceof Object); // true

// 原型链关系
console.log(B.prototype.isPrototypeOf(b)); // true
console.log(A.prototype.isPrototypeOf(b)); // true
console.log(Object.prototype.isPrototypeOf(b)); // true

2.2 自定义 instanceof 行为

class CustomClass {
  static [Symbol.hasInstance](obj) {
    return obj.hasOwnProperty('custom');
  }
}

const obj = { custom: true };
console.log(obj instanceof CustomClass); // true

const obj2 = {};
console.log(obj2 instanceof CustomClass); // false

3. 特殊情况

3.1 原始类型

// 原始类型
console.log(1 instanceof Number); // false
console.log('hello' instanceof String); // false
console.log(true instanceof Boolean); // false

// 包装对象
console.log(new Number(1) instanceof Number); // true
console.log(new String('hello') instanceof String); // true
console.log(new Boolean(true) instanceof Boolean); // true

3.2 null 和 undefined

// null 和 undefined
console.log(null instanceof Object); // false
console.log(undefined instanceof Object); // false

3.3 跨框架对象

// 跨框架对象检查
const iframe = document.createElement('iframe');
document.body.appendChild(iframe);
const iframeArray = iframe.contentWindow.Array;
const arr = new iframeArray();

console.log(arr instanceof Array); // false
console.log(arr instanceof iframeArray); // true

4. 最佳实践

4.1 类型检查

// 推荐：使用 instanceof 检查对象类型
class User {
  static isUser(obj) {
    return obj instanceof User;
  }
}

const user = new User();
console.log(User.isUser(user)); // true
console.log(User.isUser({})); // false

// 不推荐：使用 constructor 检查
console.log(user.constructor === User); // true，但可能不安全

4.2 安全检查

// 安全类型检查
function safeTypeCheck(obj, type) {
  return obj != null && obj instanceof type;
}

class DataProcessor {
  process(data) {
    if (!safeTypeCheck(data, Array)) {
      throw new Error('Data must be an array');
    }
    // 处理数据
  }
}

4.3 类型守卫

// 类型守卫
class Animal {
  static isAnimal(obj) {
    return obj instanceof Animal;
  }
}

class Dog extends Animal {
  static isDog(obj) {
    return obj instanceof Dog;
  }
}

function processAnimal(animal) {
  if (Animal.isAnimal(animal)) {
    if (Dog.isDog(animal)) {
      // 处理狗
    } else {
      // 处理其他动物
    }
  }
}

5. 注意事项

5.1 性能考虑

// 避免频繁的类型检查
class Cache {
  constructor() {
    this.items = new Map();
  }

  // 不推荐：每次访问都检查类型
  get(key) {
    if (!(key instanceof String)) {
      throw new Error('Key must be a string');
    }
    return this.items.get(key);
  }

  // 推荐：在设置时检查类型
  set(key, value) {
    if (!(key instanceof String)) {
      throw new Error('Key must be a string');
    }
    this.items.set(key, value);
  }
}

5.2 继承关系

// 注意继承关系
class Base {}
class Derived extends Base {}
const derived = new Derived();

// 原型链关系
console.log(derived instanceof Derived); // true
console.log(derived instanceof Base); // true
console.log(derived instanceof Object); // true

// 原型链顺序
console.log(Derived.prototype.isPrototypeOf(derived)); // true
console.log(Base.prototype.isPrototypeOf(derived)); // true
console.log(Object.prototype.isPrototypeOf(derived)); // true

5.3 类型安全

// 类型安全检查
class TypeSafe {
  static checkType(value, type) {
    if (value == null) {
      return false;
    }
    return value instanceof type;
  }

  static validateArray(arr) {
    return this.checkType(arr, Array) && arr.length > 0;
  }

  static validateString(str) {
    return this.checkType(str, String) && str.length > 0;
  }
}

6. 总结

6.1 使用建议

• 使用 instanceof 检查对象类型
• 注意跨框架对象检查
• 考虑性能影响
• 使用类型守卫
• 实现安全的类型检查

6.2 注意事项

• 原始类型检查
• null 和 undefined 处理
• 继承关系
• 跨框架兼容性
• 性能优化

6.3 最佳实践

• 实现类型守卫
• 使用安全的类型检查
• 避免频繁检查
• 注意继承关系
• 考虑跨框架兼容性