typeof e instanceof en JavaScript: Verificar Tipos Correctamente
Aprende a usar typeof e instanceof para verificar tipos de datos, entiende sus limitaciones y bugs, y descubre alternativas modernas más robustas.
TL;DR - Resumen rápido
- typeof retorna el tipo primitivo de un valor como string ('string', 'number', 'boolean', etc.)
- typeof null retorna 'object' (bug histórico). typeof function retorna 'function' (no 'object')
- instanceof verifica si un objeto pertenece a una clase o tiene un prototipo específico
- typeof funciona con primitivos, instanceof funciona con objetos y clases
- typeof no puede distinguir entre arrays, objetos, null - todos son 'object'
- instanceof falla con primitivos y valores de diferentes contextos (iframes)
- Alternativas modernas: Array.isArray(), Number.isNaN(), Object.prototype.toString.call()
Introducción a la Verificación de Tipos
JavaScript es un lenguaje con tipos dinámicos, lo que significa que las variables pueden contener cualquier tipo de valor y ese tipo puede cambiar en tiempo de ejecución. Para escribir código robusto, a menudo necesitas verificar qué tipo de dato tiene una variable antes de operarla. JavaScript proporciona dos operadores principales para esto: typeof para tipos primitivos, e instanceof para verificar si un objeto es instancia de una clase o constructor específico.
Sin embargo, ambos operadores tienen limitaciones y bugs históricos que debes conocer. typeof null retorna "object" en lugar de "null", typeof no puede distinguir arrays de objetos, e instanceof no funciona con primitivos. Entender cuándo usar cada uno y sus alternativas modernas es esencial para verificación de tipos robusta.
Por Qué Necesitas Verificación de Tipos
En JavaScript, una función puede recibir cualquier tipo de argumento. Sin verificación, tu código podría intentar llamar .toUpperCase() en un número, o .push() en un string, causando errores en runtime. La verificación de tipos previene estos errores validando que los valores tienen el tipo esperado antes de operarlos. TypeScript hace esto en tiempo de compilación, pero en JavaScript vanilla necesitas hacerlo manualmente.
El Operador typeof
typeof es un operador unario que retorna un string indicando el tipo del operando. Es útil para verificar tipos primitivos como string, number, boolean, undefined, symbol, y bigint. La sintaxis es typeof valor, y siempre retorna un string. typeof nunca lanza errores, incluso con variables no declaradas retorna "undefined" en lugar de ReferenceError.
typeof con Tipos Primitivos
Con tipos primitivos, typeof funciona como esperarías en la mayoría de casos. Retorna "string" para strings, "number" para números (incluyendo Infinity y NaN), "boolean" para booleanos, "undefined" para undefined, "symbol" para symbols, y "bigint" para bigints. Es la forma más confiable de verificar estos tipos.
typeof retorna strings en minúsculas: "string", "number", etc. Nota que typeof NaN retorna "number" (aunque NaN significa Not a Number), y typeof Infinity también es "number". Para verificar específicamente NaN, usa Number.isNaN() en lugar de typeof. typeof puede usarse con variables no declaradas sin causar error - retorna "undefined".
typeof No Lanza ReferenceError
Único entre operadores, typeof puede usarse con variables no declaradas sin lanzar ReferenceError. typeof variableQueNoExiste retorna "undefined" en lugar de error. Esto es útil para verificar si una variable global existe: if (typeof globalVariable !== 'undefined'). Sin embargo, en código moderno con let/const, es mejor verificar con try/catch o simplemente declarar todas las variables.
typeof con Objetos y Funciones
Con objetos, typeof tiene comportamientos especiales. Arrays, objetos, y null todos retornan "object" (typeof null es un bug histórico). Las funciones son la excepción - typeof function retorna "function" en lugar de "object", aunque técnicamente las funciones son objetos. Esto hace que typeof sea poco útil para distinguir entre tipos de objetos.
typeof no puede distinguir entre objetos, arrays, null, o Date - todos retornan "object". Las funciones son especiales: typeof retorna "function" para funciones normales, arrow functions, métodos, clases, y funciones asíncronas. Para verificar si algo es array, usa Array.isArray(). Para null, usa comparación estricta === null. Para otros objetos específicos, usa instanceof o Object.prototype.toString.call().
typeof No Distingue Tipos de Objetos
typeof es inútil para distinguir entre tipos de objetos. , [], new Date(), /regex/, y new Map() todos retornan "object". No puedes usar typeof para verificar si algo es un array o una fecha. Para arrays usa Array.isArray(). Para otros tipos de objetos, usa instanceof o métodos específicos como obj instanceof Date.
Problemas y Bugs de typeof
typeof tiene varios problemas históricos que debes conocer. El más famoso es typeof null que retorna "object" en lugar de "null" - este bug existe desde JavaScript 1.0 y no se puede arreglar por retrocompatibilidad. También, typeof NaN es "number" que es contraintuitivo, y typeof no puede detectar arrays o distinguir entre tipos de objetos.
Los problemas principales son: typeof null retorna "object" (bug desde 1995), typeof NaN retorna "number" (aunque NaN significa Not a Number), typeof no distingue arrays de objetos, y typeof puede dar resultados inesperados con objetos creados en diferentes contextos (iframes). Para verificar null usa comparación estricta (value === null). Para NaN usa Number.isNaN(). Para arrays usa Array.isArray().
El Operador instanceof
instanceof es un operador binario que verifica si un objeto pertenece a una clase específica o tiene un constructor específico en su cadena de prototipos. La sintaxis es objeto instanceof Constructor, y retorna true o false. Es útil para verificar si un objeto es instancia de Array, Date, RegExp, o clases personalizadas. Sin embargo, no funciona con primitivos ni con valores de diferentes contextos.
Uso Básico de instanceof
instanceof verifica si el prototipo de un constructor aparece en la cadena de prototipos de un objeto. En términos simples, verifica si un objeto fue creado con un constructor específico o hereda de él. Es la forma principal de verificar tipos de objetos específicos como arrays, fechas, expresiones regulares, y clases personalizadas.
instanceof funciona con todos los tipos de objetos: arrays, fechas, expresiones regulares, errores, y clases personalizadas. Retorna true si el objeto fue creado con ese constructor o hereda de él. Sin embargo, instanceof NO funciona con primitivos - [1, 2, 3] instanceof Array es true, pero "hola" instanceof String es false (aunque "hola" es un string primitivo, no un objeto String).
instanceof No Funciona con Primitivos
instanceof solo funciona con objetos, no con primitivos. "hola" instanceof String es false, 5 instanceof Number es false, true instanceof Boolean es false. Estos son primitivos, no objetos. Si creas objetos wrapper con new String("hola"), entonces instanceof funciona, pero NUNCA deberías usar objetos wrapper - usa primitivos siempre.
instanceof y Herencia
instanceof verifica toda la cadena de prototipos, no solo el constructor inmediato. Esto significa que un objeto puede ser instanceof de múltiples constructores si hay herencia. Por ejemplo, un array es instanceof Array, pero también instanceof Object porque Array hereda de Object. Esto es útil para verificar herencia en clases personalizadas.
instanceof recorre la cadena de prototipos completa. Un array es instanceof Array y también instanceof Object porque Array.prototype hereda de Object.prototype. Con clases personalizadas que usan extends, una instancia de clase hija es instanceof de la clase padre también. Esto es útil para polimorfismo y verificar que un objeto cumple una interfaz específica, especialmente en jerarquías de clases.
typeof vs instanceof: Cuándo Usar Cada Uno
typeof e instanceof sirven propósitos diferentes y no son intercambiables. typeof verifica tipos primitivos y retorna un string con el tipo. instanceof verifica si un objeto es instancia de una clase y retorna boolean. Usa typeof para primitivos (string, number, boolean, undefined, symbol, bigint) y funciones. Usa instanceof para objetos específicos (arrays, fechas, clases personalizadas).
typeof es mejor para primitivos: typeof x === 'string', typeof x === 'number'. instanceof es mejor para objetos: arr instanceof Array, fecha instanceof Date. typeof retorna string, instanceof retorna boolean. typeof funciona con primitivos, instanceof solo con objetos. typeof nunca lanza error, instanceof puede lanzar TypeError si el lado derecho no es un constructor. No puedes usar instanceof con primitivos, y typeof no puede distinguir tipos de objetos.
Regla Simple: Primitivos vs Objetos
Regla simple: usa typeof para primitivos (string, number, boolean, undefined, symbol, bigint) y para verificar si algo es función. Usa instanceof para objetos específicos (Array, Date, RegExp, Error, clases personalizadas). Para verificar null usa comparación estricta: value === null. Para arrays usa Array.isArray() que es más confiable que instanceof.
Alternativas Modernas y Más Robustas
JavaScript moderno proporciona métodos más robustos y específicos para verificación de tipos que evitan los problemas de typeof e instanceof. Array.isArray() verifica arrays confiablemente, Number.isNaN() verifica NaN correctamente, Number.isFinite() verifica números válidos, y Object.prototype.toString.call() da el tipo exacto de cualquier valor.
Estas alternativas son más confiables que typeof/instanceof. Array.isArray() funciona incluso con arrays de otros contextos (iframes). Number.isNaN() solo retorna true para NaN (no para strings no-numéricos como el NaN global). Number.isFinite() verifica que un valor sea un número finito (no Infinity, no NaN). Object.prototype.toString.call() da el tipo exacto como "[object Array]", "[object Date]", etc. - útil cuando necesitas el tipo exacto.
Métodos Modernos Son Más Confiables
Prefiere métodos modernos específicos sobre typeof/instanceof cuando existen. Array.isArray() es mejor que instanceof Array. Number.isNaN() es mejor que typeof x === 'number' && isNaN(x). Number.isInteger() verifica enteros directamente. Estos métodos son más claros, más confiables, y comunican mejor la intención del código. Son el estándar en código JavaScript moderno.
Casos Prácticos de Verificación de Tipos
En código real, necesitas verificación de tipos en validación de argumentos de función, procesamiento de datos de APIs, manejo de inputs de usuario, y código defensivo. Aquí hay patrones comunes usando typeof, instanceof, y alternativas modernas para escribir funciones robustas que manejan tipos correctamente y fallan de forma predecible.
La verificación de tipos práctica combina múltiples técnicas. Valida argumentos al inicio de funciones y lanza errores descriptivos si los tipos son incorrectos. Verifica null/undefined antes de acceder a propiedades (o usa optional chaining). Usa métodos específicos (Array.isArray, Number.isNaN) en lugar de typeof/instanceof cuando estén disponibles. Documenta los tipos esperados en comentarios o usa JSDoc. Considera TypeScript para verificación de tipos automática en proyectos grandes.
Resumen: typeof e instanceof
Conceptos clave:
- •typeof retorna string con el tipo primitivo del valor
- •typeof null retorna 'object' (bug histórico), typeof function retorna 'function'
- •instanceof verifica si objeto es instancia de una clase o constructor
- •typeof funciona con primitivos, instanceof solo con objetos
- •instanceof verifica toda la cadena de prototipos (herencia)
Mejores prácticas:
- •Usa typeof para primitivos, instanceof para objetos específicos
- •Para arrays usa Array.isArray() en lugar de instanceof Array
- •Para NaN usa Number.isNaN(), para null usa === null
- •Prefiere métodos específicos modernos sobre typeof/instanceof
- •Valida tipos de argumentos al inicio de funciones críticas