Determinar el tipo de una variable en JavaScript

En JavaScript a veces vas a tener que identificar el tipo de un objeto o variable en tiempo de ejecución.

JavaScript es un lenguaje de tipado dinámico, lo que significa que el tipo de una variable se determina y puede cambiar durante la ejecución del programa.

Debido a esta flexibilidad, a veces no es tan sencillo determinar el tipo exacto de un valor. Vamos a ver las distintas opciones 👇.

Métodos para determinar el tipo en JavaScript

En JavaScript existen distintos métodos para para identificar el tipo de un objeto o variable. La elección del método depende del caso de uso (y del nivel de precisión que necesites).

Verificas valores primitivos typeof

El operador typeof es el método más simple y común para determinar el tipo de una variable. Devuelve una cadena que indica el tipo del valor evaluado.

typeof valor;

Por ejemplo,

console.log(typeof 42);           // "number"
console.log(typeof "Hola");       // "string"
console.log(typeof true);         // "boolean"
console.log(typeof undefined);    // "undefined"
console.log(typeof null);         // "object" (peculiaridad histórica)
console.log(typeof {});           // "object"
console.log(typeof []);           // "object" (pero es un array)
console.log(typeof function(){}); // "function"

Verificar si es instancia de una clase instanceof

El operador instanceof verifica si un objeto es una instancia de una clase o si hereda de su prototipo.

objeto instanceof Clase;

Por ejemplo,

class Persona {}
const juan = new Persona();

console.log(juan instanceof Persona); // true
console.log([] instanceof Array);     // true
console.log({} instanceof Object);    // true

Identificar tipos específicos Object.prototype

El método Object.prototype.toString() es una técnica bastante útil para determinar el tipo de un objeto.

Sintaxis:

Object.prototype.toString.call(valor);

Este método nos devolvería siempre una cadena que tendrá la forma [object Tipo]. Por ejemplo,

console.log(Object.prototype.toString.call(42));         // "[object Number]"
console.log(Object.prototype.toString.call("Hola"));     // "[object String]"
console.log(Object.prototype.toString.call([]));         // "[object Array]"
console.log(Object.prototype.toString.call({}));         // "[object Object]"
console.log(Object.prototype.toString.call(null));       // "[object Null]"
console.log(Object.prototype.toString.call(undefined));  // "[object Undefined]"
console.log(Object.prototype.toString.call(function(){})); // "[object Function]"
console.log(Object.prototype.toString.call(new Date())); // "[object Date]"

Verificar el constructor constructor

Otra forma es emplear la propiedad constructor de un objeto que hace referencia a la función constructora que lo creó.

objeto.constructor;

Esto puede ser útil para identificar tipos personalizados.. Por ejemplo,

const fecha = new Date();
console.log(fecha.constructor === Date); // true

const miArray = [];
console.log(miArray.constructor === Array); // true

Identificar el prototipo prototype.name

Algunos prototipos (como los creados con clases personalizadas) tienen una propiedad name que indica su tipo.

Esto es útil cuando queremos identificar entre las clases personalizadas (como las creadas por nosotros mismos). Por ejemplo,

// aquí iría la definición de tu clase
class Vehiculo { }

const auto = new Vehiculo();
console.log(auto.constructor.name); // "Vehiculo"

Combinación de métodos

En la práctica, a veces será necesario combinar múltiples métodos para identificar tipos con mayor precisión.

Por ejemplo, puedes usar typeof para valores primitivos y Object.prototype.toString para objetos complejos:

function obtenerTipo(valor) {
  if (typeof valor === "object") {
    if (valor === null) return "null";
    if (Array.isArray(valor)) return "array";
    return Object.prototype.toString.call(valor).slice(8, -1).toLowerCase();
  }
  return typeof valor;
}

console.log(obtenerTipo(42));           // "number"
console.log(obtenerTipo("Hola"));       // "string"
console.log(obtenerTipo([]));           // "array"
console.log(obtenerTipo({}));           // "object"
console.log(obtenerTipo(null));         // "null"
console.log(obtenerTipo(undefined));    // "undefined"