Cómo comprobar si una variable es una cadena en JavaScript

Usa typeof value === "string" para comprobar si un valor es una cadena primitiva. Suele ser la opción adecuada para validar datos. Las comillas simples, las dobles y los acentos graves crean cadenas primitivas; el estilo de las comillas no cambia el tipo.

Comprueba las cadenas primitivas con typeof

El operador typeof devuelve la cadena "string" para una cadena primitiva. Compara el resultado con ese valor exacto. La comparación da falso para números, valores booleanos, null y objetos. Funciona con valores locales, argumentos de funciones y valores recibidos de otro código.

Ejecuta este ejemplo:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

const primitive = "hello";
const boxed = new String("hello");
const number = 42;

console.log(typeof primitive);
console.log(typeof boxed);
console.log(typeof number === "string");

string
object
false

La cadena primitiva produce "string"; el valor creado con new String("hello") produce "object"; y 42 no supera la comparación para cadenas primitivas. Al validar un valor, usa la comparación typeof value === "string".

Decide si aceptar objetos String

JavaScript también tiene objetos String, a veces llamados cadenas envueltas. new String("hello") crea uno, mientras que String("hello"), sin new, devuelve una cadena primitiva. Es preferible usar cadenas primitivas: los valores envueltos se comportan como objetos y pueden causar sorpresas en las comparaciones y las API.

La comprobación con typeof acepta cadenas primitivas y rechaza objetos String, porque typeof new String("hello") es "object". Ese suele ser el comportamiento adecuado al validar entradas. Si una API acepta intencionadamente ambas formas, decide explícitamente si las admite en lugar de relajar todas las comprobaciones de cadenas.

value instanceof String comprueba si String.prototype del entorno actual aparece en la cadena de prototipos del valor. Devuelve falso para cadenas primitivas y también puede devolverlo para un objeto String auténtico creado en otro entorno, como otra ventana o marco del navegador. Esta comprobación no demuestra que el objeto contenga los datos internos propios de una cadena envoltorio.

Comprende los límites de las comprobaciones alternativas

Object.prototype.toString.call(value) === "[object String]" puede identificar cadenas primitivas y objetos String comunes, incluidos muchos objetos de otros entornos. No es una prueba universal de autenticidad: los objetos pueden personalizar el resultado mediante Symbol.toStringTag. Usa esta comprobación solo si esa limitación es compatible con los valores que maneja tu código.

String.prototype.isPrototypeOf(value) comprueba si String.prototype del entorno actual aparece en la cadena de prototipos de un objeto. Se aplica a objetos, no a valores primitivos, y tiene una limitación entre entornos similar a la de instanceof. Ni este método ni instanceof String demuestran que el valor sea un objeto String envoltorio auténtico o que contenga datos internos de cadena: por ejemplo, Object.create(String.prototype) puede superar ambas comprobaciones de la cadena de prototipos. Estas comprobaciones responden a preguntas distintas y no son intercambiables. Para la validación de tipos habitual, usa typeof value === "string" y decide por separado si quieres aceptar objetos envueltos.

Preguntas frecuentes

¿Cómo compruebo si una variable es una cadena en JavaScript?

Usa typeof value === "string" para aceptar cadenas primitivas. Es la opción habitual para la mayoría de las entradas de una aplicación. Si también aceptas valores envueltos, define esa política por separado: las comprobaciones de la cadena de prototipos, por sí solas, no demuestran que un objeto sea un objeto String envoltorio auténtico.

¿Cuál es la diferencia entre las cadenas primitivas y los objetos String?

Una cadena primitiva es un valor de tipo cadena. new String("hello") crea un objeto que la envuelve, por lo que typeof devuelve "object". Prefiere las cadenas primitivas, salvo que una API necesite específicamente un objeto String.

¿instanceof String funciona con cadenas primitivas?

No. instanceof comprueba si un objeto hereda del constructor String del entorno actual. Las cadenas primitivas no son objetos.

¿Qué comprobación debería elegir?

Usa typeof para validar cadenas primitivas. Usa instanceof String o String.prototype.isPrototypeOf() solo cuando necesites comprobar una cadena de prototipos String del mismo entorno; ninguno de los dos demuestra que se trate de un objeto envoltorio auténtico. Usa Object.prototype.toString.call() si necesitas reconocer cadenas primitivas y envueltas, teniendo en cuenta que Symbol.toStringTag puede personalizar el resultado. Un objeto envoltorio auténtico de otro entorno puede no superar las comprobaciones de prototipos del entorno actual.