Verificación de tipo string en JavaScript: guía completa

Entrenador de Python en Línea para Principiantes

Aprende Python fácilmente sin sobrecargarte de teoría. Resuelve tareas prácticas con verificación automática, recibe pistas y escribe código directamente en el navegador, sin instalar nada.

Start Course

«¿Es una cadena?» — la pregunta que atormenta a todo desarrollador de JavaScript

Estás escribiendo código y de repente te detienes. La variable debería contener una cadena, pero ¿y si llegó un null? ¿O un número? ¿O, peor aún, undefined?

¿Te suena familiar? Si es así, no estás solo. La pregunta «Check if a variable is a string in JavaScript» es una de las más populares en Stack Overflow con decenas de miles de visitas. Y no es casualidad: JavaScript es un lenguaje de tipado dinámico, y los errores relacionados con tipos ocurren incluso en desarrolladores experimentados.

En este artículo analizaremos todas las formas posibles de verificar si una variable es una cadena. Aprenderás:

Por qué typeof es tu mejor amigo (pero no siempre)
Cuándo instanceof falla
Cómo funciona el método «francotirador» Object.prototype.toString
Y qué hacer si usas bibliotecas

¡Allá vamos! 🚀

Método n.º 1: typeof — el clásico del género

La forma más simple y rápida es el operador typeof. Devuelve una cadena con el nombre del tipo:

const name = "Alicia";const age = 25;const isAdmin = true;

console.log(typeof name);    // "string"console.log(typeof age);     // "number"console.log(typeof isAdmin); // "boolean"

La verificación de cadena se ve así:

if (typeof variable === "string") {  console.log("¡Sí, es una cadena!");}

Ventajas:

Funciona rápido
No requiere importación
Legible

Desventajas:

No distingue el primitivo "cadena" del objeto new String("cadena")
Para null devuelve "object" (error histórico de JavaScript)

Por cierto, sobre null — es un error conocido del lenguaje que ya no se corregirá para no romper sitios antiguos. Así que typeof null === "object" es normal.

¿Y qué pasa con new String()?

En JavaScript hay dos tipos de cadenas: primitivas (normales) y de objeto (creadas con new String()). En la práctica casi nunca usarás new String(), pero vale la pena conocerlo:

const primitiveString = "Hola";const objectString = new String("Hola");

console.log(typeof primitiveString); // "string"console.log(typeof objectString);    // "object"

Si en tu código alguien (o algo) pasa una cadena de objeto, typeof te engañará. Pero no te preocupes: en proyectos reales esto ocurre raramente.

Método n.º 2: instanceof — para cadenas de objeto

El operador instanceof verifica si un objeto es una instancia de una clase determinada:

const str = new String("Prueba");console.log(str instanceof String); // true

const str2 = "Prueba";console.log(str2 instanceof String); // false — porque es un primitivo

Como ves, instanceof no funciona con cadenas primitivas. Por eso se usa raramente — solo si sabes con certeza que trabajas con objetos.

¿Cuándo puede ser útil? Si estás escribiendo una biblioteca que acepta tanto primitivos como objetos. Pero para el 99% de los casos, typeof será suficiente.

Método n.º 3: Object.prototype.toString.call() — el soldado universal

Este método es un verdadero francotirador. Funciona para cualquier tipo de dato y nunca se equivoca:

function isString(value) {  return Object.prototype.toString.call(value) === "[object String]";}

console.log(isString("Hola"));        // trueconsole.log(isString(new String("Hola"))); // trueconsole.log(isString(123));             // falseconsole.log(isString(null));            // falseconsole.log(isString(undefined));       // false