Resumen: en este tutorial, aprenderás a usar el operador instanceof de JavaScript para determinar si un objeto en su cadena de prototipos contiene la propiedad prototype de un constructor.
Introducción al operador instanceof de JavaScript
Utilice instanceof cuando necesites confirmar el tipo de un objeto en tiempo de ejecución. Por ejemplo, cuando controle excepciones, puede recurrir a diferentes códigos de manipulación de excepciones dependiendo del tipo de excepción tomada.
Debes especificar un objeto en el lado derecho del operador instanceof. Por ejemplo, puedes especificar una cadena creada con el constructor String, pero no puedes especificar un literal de cadena.
A continuación, se muestra la sintaxis del operador instanceof:
object instanceof constructor
En esta sintaxis:
- object es el objeto a probar.
- constructor es una función para probar.
Ejemplo de operador instanceof de JavaScript
El siguiente ejemplo define el tipo Person y usa el operador instanceof para verificar si un objeto es una instancia de ese tipo:
function Person(name) {
this.name = name;
}
let p1 = new Person('John');
console.log(p1 instanceof Person); // true
Cómo funciona.
Primero, defines un tipo Person usando el patrón de la función constructora:
function Person(name) {
this.name = name;
}
En segundo lugar, crea un nuevo objeto del tipo Person:
let p1 = new Person('John Doe');
En tercer lugar, comprueba si p1 es una instancia del tipo Person:
console.log(p1 instanceof Person); // true
Devuelve verdadero porque Person.prototype aparece prototype del objeto p1. Resumiendo, prototype del p1 es el enlace entre p1, Persona.prototype y Objeto.prototype:
Lo siguiente también devuelve verdadero porque Object.prototype aparece en la cadena de prototipos del objeto p1:
console.log(p1 instanceof Object); // true
Clase ES6 y operador instanceof
El siguiente ejemplo define la clase Person y usa el operador instanceof para verificar si un objeto es una instancia de una clase:
class Person {
constructor(name) {
this.name = name;
}
}
let p1 = new Person('John');
console.log(p1 instanceof Person); // true
Cómo funciona.
Primero, define la clase Person:
class Person {
constructor(name) {
this.name = name;
}
}
En segundo lugar, crea una nueva instancia de la clase Person:
let p1 = new Person('John');
Tercero, verifica si p1 es una instancia de la clase Person:
console.log(p1 instanceof Person); // true
El operador instanceof y la herencia.
El siguiente ejemplo define la clase Employee que amplía la clase Person:
class Person {
constructor(name) {
this.name = name;
}
}
class Employee extends Person {
constructor(name, title) {
super(name);
this.title = title;
}
}
let e1 = new Employee();
console.log(e1 instanceof Employee); // true
console.log(e1 instanceof Person); // true
console.log(e1 instanceof Object); // true
Dado que e1 es una instancia de la clase Employee, también es una instancia de las clases Person y Object (clases base).
Symbol.hasInstance
En ES6, el operador instanceof usa la función Symbol.hasInstance para verificar la relación. Symbol.hasInstance() acepta un objeto y devuelve verdadero si un tipo tiene ese objeto como instancia. Por ejemplo:
class Person {
constructor(name) {
this.name = name;
}
}
let p1 = new Person('John');
console.log(Person[Symbol.hasInstance](p1)); // true
Dado que Symbol.hasInstance está definido en el prototipo de función, está disponible automáticamente de forma predeterminada en todas las funciones y clases.
Y puedes redefinir Symbol.hasInstance en una subclase como un método estático. Por ejemplo:
class Person {
constructor(name) {
this.name = name;
}
}
class Android extends Person {
static [Symbol.hasInstance]() {
return false;
}
}
let a1 = new Android('Sonny');
console.log(a1 instanceof Android); // false
console.log(a1 instanceof Person); // false
Resumen: Utiliza el operador instanceof para comprobar si el constructor.protoype está en la cadena de prototipos del objeto.
