Home / Lenguajes / Buscar subcadenas en JavaScript: includes, indexOf y regex al detalle
Buscar subcadenas en JavaScript: includes, indexOf y regex al detalle

Buscar subcadenas en JavaScript: includes, indexOf y regex al detalle

16 November 2026 · 17 min de lectura ··

Por qué buscar texto dentro de texto es una tarea diaria

Casi cualquier aplicación necesita responder, tarde o temprano, a una pregunta muy simple: ¿este texto contiene aquel fragmento? Un buscador que filtra una lista de productos mientras el usuario escribe, una validación que comprueba que un correo pertenece a un dominio corporativo, un script que revisa registros en busca de la palabra ERROR o un middleware que decide si una ruta empieza por un prefijo concreto. Todos ellos se reducen a localizar una subcadena dentro de una cadena más grande.

JavaScript ofrece varias herramientas para esto y no todas sirven para lo mismo. Algunas devuelven un valor booleano, otras una posición, y otras permiten describir patrones complejos. Elegir la correcta evita código confuso y errores sutiles, sobre todo con mayúsculas, caracteres especiales y valores que no son realmente cadenas.

En este tutorial recorreremos las opciones modernas y las clásicas, con ejemplos que puedes ejecutar tal cual en la consola del navegador o en Node.js. Los ejemplos se han comprobado pensando en un entorno actual: la línea Current de Node.js es la 26.x y la versión LTS vigente es la 24.x, y ambas soportan todo lo que verás aquí sin configuración adicional. Los métodos principales llevan años estandarizados, así que el código funciona también en cualquier navegador moderno.

Al terminar sabrás cuándo usar includes(), cuándo preferir indexOf(), cómo hacer búsquedas que ignoren mayúsculas, cómo apoyarte en startsWith() y endsWith(), y en qué casos merece la pena recurrir a expresiones regulares.

Qué entendemos por subcadena

Una subcadena es cualquier secuencia contigua de caracteres que aparece dentro de otra cadena. En "programacion", los fragmentos "gram", "ion" y "p" son subcadenas; en cambio "pgm" no lo es, porque sus letras aparecen en ese orden pero no seguidas. Toda cadena es subcadena de sí misma y la cadena vacía se considera subcadena de cualquier texto, un detalle que más adelante nos dará un par de sorpresas.

Conviene recordar también que las cadenas de JavaScript son inmutables y que se indexan desde cero. La posición 0 corresponde al primer carácter, y la última posición es longitud - 1. Todos los métodos que veremos respetan esa convención.

const nota = "Entrega del informe trimestral";

console.log(nota.length);   // 30
console.log(nota[0]);       // "E"
console.log(nota.at(-1));   // "l"
30
E
l

El método at() con índice negativo permite acceder al final de la cadena sin calcular la longitud, y es una forma cómoda y actual de leer el último carácter.

El método includes para responder sí o no

Desde ES2015, las cadenas disponen de includes(). Recibe la subcadena que buscas y, de forma opcional, la posición desde la que empezar. Devuelve true si la encuentra y false en caso contrario. Es la opción más legible cuando solo te interesa saber si el fragmento está.

const mensaje = "El servidor respondió con código 503";

console.log(mensaje.includes("servidor")); // true
console.log(mensaje.includes("cliente"));  // false
console.log(mensaje.includes("503"));      // true
true
false
true

Su lectura casi se corresponde con una frase en lenguaje natural, y por eso se usa tanto en condiciones.

function esErrorDeServidor(linea) {
  return linea.includes("503") || linea.includes("500");
}

if (esErrorDeServidor(mensaje)) {
  console.log("Avisar al equipo de guardia");
}

La posición inicial opcional

El segundo argumento indica en qué índice comienza la búsqueda. Todo lo que quede antes de esa posición se ignora. Es útil cuando ya sabes que el principio del texto no te interesa, por ejemplo una cabecera de longitud fija.

const registro = "2026-11-16 INFO inicio correcto";

console.log(registro.includes("INFO"));      // true
console.log(registro.includes("2026", 5));   // false
console.log(registro.includes("INFO", 11));  // true
true
false
true

En la segunda línea la búsqueda empieza en el índice 5, así que el año, que está al principio, queda fuera. Si pasas un número negativo o cero, se trata como si fuera cero; si pasas un valor mayor que la longitud, solo se compara contra la cadena vacía.

Búsquedas que distinguen mayúsculas

includes() es sensible a mayúsculas y minúsculas. Es la causa más frecuente de que una búsqueda aparentemente correcta devuelva false.

const saludo = "Buenos Días";

console.log(saludo.includes("días")); // false
console.log(saludo.includes("Días")); // true
false
true

Más adelante veremos cómo neutralizar esa diferencia cuando el caso lo pide.

El método indexOf cuando necesitas la posición

indexOf() es el método veterano. Acepta los mismos argumentos que includes(), pero en vez de un booleano devuelve el índice donde empieza la primera coincidencia, o -1 si no hay ninguna. Esa información extra lo hace imprescindible cuando quieres cortar el texto a partir del hallazgo.

const ruta = "/usuarios/42/perfil";

console.log(ruta.indexOf("usuarios")); // 1
console.log(ruta.indexOf("perfil"));   // 13
console.log(ruta.indexOf("admin"));    // -1
1
13
-1

Para usarlo como comprobación de existencia, se compara el resultado con -1.

if (ruta.indexOf("perfil") !== -1) {
  console.log("La ruta apunta al perfil");
}

Funciona, pero resulta menos expresivo que includes(). Por eso, en código nuevo, conviene reservar indexOf() para los casos en que de verdad necesitas el número.

Extraer lo que hay después de una coincidencia

Un uso muy práctico es combinar la posición con slice() para obtener una parte del texto.

const correo = "[email protected]";
const arroba = correo.indexOf("@");

if (arroba !== -1) {
  const usuario = correo.slice(0, arroba);
  const dominio = correo.slice(arroba + 1);
  console.log(usuario); // "ana.lopez"
  console.log(dominio); // "empresa.example"
}
ana.lopez
empresa.example

Aquí includes() no te habría servido, porque necesitas saber dónde está el separador y no solo que existe.

Un error clásico con el índice cero

El fallo más habitual con indexOf() aparece cuando se usa el resultado directamente como condición. Si la coincidencia está al principio, el método devuelve 0, que en JavaScript es un valor falsy, y la condición falla aunque la subcadena exista.

const archivo = "informe-final.pdf";

// Incorrecto: 0 se evalúa como falso
if (archivo.indexOf("informe")) {
  console.log("Contiene informe");
} else {
  console.log("No lo contiene");
}
No lo contiene

La salida es engañosa. La forma correcta es comparar explícitamente con -1, o mejor aún, cambiar a includes(), que devuelve un booleano real y no tiene esta trampa.

Buscar desde el final con lastIndexOf

Cuando hay varias coincidencias y quieres la última, existe lastIndexOf(). Recorre la cadena de derecha a izquierda y devuelve la posición de la aparición más tardía.

const nombreArchivo = "copia.de.seguridad.tar.gz";

const ultimoPunto = nombreArchivo.lastIndexOf(".");
console.log(nombreArchivo.slice(ultimoPunto + 1)); // "gz"
gz

Es el método ideal para obtener extensiones o el último segmento de una ruta.

Diferencias entre includes e indexOf

Ambos hacen una búsqueda literal y sensible a mayúsculas, pero se distinguen en detalles que importan.

  • includes() devuelve un booleano; indexOf() devuelve un número.
  • includes() lanza un TypeError si le pasas una expresión regular, mientras que indexOf() convierte el argumento a texto y busca esa representación.
  • Con el valor NaN en arreglos, includes() se comporta distinto que indexOf(), pero esa diferencia pertenece a los arreglos y no a las cadenas.
  • Para cadenas, includes() es más claro en condiciones y indexOf() es más adecuado cuando hay que calcular cortes.

Esa segunda diferencia merece una demostración, porque evita confusiones al pasar de un método a otro.

const texto = "precio: 10+";

try {
  console.log(texto.includes(/\d+/));
} catch (error) {
  console.log(error.name);
}

console.log(texto.indexOf("10+")); // 8
TypeError
8

Si quieres usar un patrón, necesitas otra herramienta, que veremos en la sección de expresiones regulares.

Ignorar mayúsculas y minúsculas

Cuando el usuario escribe en un buscador, no suele importarle si pone Madrid o madrid. La técnica más simple es normalizar ambos lados de la comparación a minúsculas antes de buscar.

const ciudad = "Ciudad de Madrid";
const consulta = "MADRID";

const coincide = ciudad.toLowerCase().includes(consulta.toLowerCase());
console.log(coincide); // true
true

Conviene encapsular la idea en una función pequeña que puedas reutilizar.

function contieneSinDistinguir(texto, fragmento) {
  return texto.toLowerCase().includes(fragmento.toLowerCase());
}

const titulos = [
  "Guía de Docker para principiantes",
  "Introducción a SQL",
  "Docker Compose en producción",
];

const filtrados = titulos.filter((t) => contieneSinDistinguir(t, "docker"));
console.log(filtrados);
[ 'Guía de Docker para principiantes', 'Docker Compose en producción' ]

Acentos y diacríticos

Pasar a minúsculas no resuelve las tildes: "canción" y "cancion" siguen siendo distintas. Para una búsqueda realmente tolerante, normaliza la cadena a su forma descompuesta y elimina las marcas diacríticas.

function limpiar(texto) {
  return texto
    .normalize("NFD")
    .replace(/[̀-ͯ]/g, "")
    .toLowerCase();
}

console.log(limpiar("Canción Ñandú")); // "cancion nandu"
console.log(limpiar("Canción").includes(limpiar("CANCION"))); // true
cancion nandu
true

Ten presente que esta limpieza también transforma la ñ en n, algo que puede ser deseable en un buscador y inaceptable en una validación estricta.

Comparación con localeCompare

Otra vía es localeCompare() con la opción sensitivity: "base", que compara ignorando mayúsculas y acentos según el idioma. Sirve para igualdad completa, no para contención, así que no reemplaza a includes(), pero resulta útil cuando quieres saber si dos textos son equivalentes a efectos del usuario.

const iguales = "Árbol".localeCompare("arbol", "es", { sensitivity: "base" }) === 0;
console.log(iguales); // true
true

Comprobar el principio y el final con startsWith y endsWith

Muchas veces no interesa que el fragmento esté en cualquier parte, sino específicamente al comienzo o al final. Para esos casos existen startsWith() y endsWith(). Son más precisos y expresan mejor la intención que includes().

const url = "https://ejemplo.test/api/v2/clientes";

console.log(url.startsWith("https://"));   // true
console.log(url.endsWith("/clientes"));    // true
console.log(url.startsWith("api", 20));    // depende de la posición
true
true
false

startsWith() admite una posición inicial como segundo argumento, y endsWith() acepta una longitud que actúa como si la cadena terminara antes. Esto permite comprobar prefijos o sufijos en zonas internas del texto.

Un caso real es clasificar archivos por su extensión.

const archivos = ["foto.png", "notas.txt", "diagrama.svg", "logo.png"];

const imagenes = archivos.filter(
  (a) => a.endsWith(".png") || a.endsWith(".svg")
);

console.log(imagenes);
[ 'foto.png', 'diagrama.svg', 'logo.png' ]

Si en lugar de endsWith() hubieras usado includes(".png"), un archivo llamado copia.png.bak habría pasado el filtro por error. Escoger el método más específico previene este tipo de falsos positivos.

Expresiones regulares para patrones y flexibilidad

Cuando la búsqueda deja de ser literal, las expresiones regulares toman el relevo. Permiten describir formas: dígitos, alternativas, límites de palabra o repeticiones. El método más directo para saber si un patrón aparece es test(), que pertenece a RegExp y devuelve un booleano.

const patronPedido = /pedido-\d{4}/;

console.log(patronPedido.test("Confirmado pedido-2048 hoy")); // true
console.log(patronPedido.test("Confirmado pedido-20 hoy"));   // false
true
false

La bandera i hace que el patrón ignore mayúsculas sin tener que transformar el texto original, lo que resulta más eficiente y limpio que toLowerCase() en muchos escenarios.

const buscaError = /error/i;

console.log(buscaError.test("Fallo: ERROR de conexión")); // true
console.log(buscaError.test("Todo correcto"));            // false
true
false

Límites de palabra

Una búsqueda literal de "sol" encuentra también "solución" o "resolver". Si quieres la palabra completa, el metacarácter \b marca el límite entre letra y no letra.

const palabraSol = /\bsol\b/i;

console.log(palabraSol.test("Hoy hay sol y calor")); // true
console.log(palabraSol.test("Busco una solución"));  // false
true
false

Para textos con tildes, recuerda que \b en JavaScript considera letras solo los caracteres ASCII salvo que uses la bandera u con propiedades Unicode. En esos casos, una alternativa robusta es \p{L} junto con u.

Obtener la coincidencia con match y matchAll

test() solo dice si existe. Si necesitas el contenido, match() devuelve el resultado, y con la bandera g entrega todas las apariciones. Para tener además las posiciones y los grupos de captura, matchAll() devuelve un iterador.

const texto = "Contactos: [email protected], [email protected]";
const patronCorreo = /[\w.]+@[\w.]+/g;

for (const m of texto.matchAll(patronCorreo)) {
  console.log(m[0], "en la posición", m.index);
}
[email protected] en la posición 11
[email protected] en la posición 28

Es una herramienta potente, pero para comprobar si hay un fragmento literal resulta excesiva. Una regla práctica: si puedes resolverlo con includes(), startsWith() o endsWith(), hazlo así, y reserva las expresiones regulares para cuando la búsqueda exige un patrón.

Escapar caracteres especiales

Si vas a construir una expresión regular a partir de texto introducido por un usuario, debes escapar los caracteres con significado especial; de lo contrario, un punto, un paréntesis o un signo más cambiarán el sentido de la búsqueda e incluso podrían provocar errores o consumo excesivo de recursos.

function escapar(texto) {
  return texto.replace(/[.*+?^$()|[\]\\]/g, "\\$&");
}

const entrada = "c++ (avanzado)";
const patron = new RegExp(escapar(entrada), "i");

console.log(patron.test("Curso de C++ (avanzado) en línea")); // true
true

Si sin más pasaras esa entrada a new RegExp(), el motor lanzaría un error por el paréntesis sin cerrar o por la repetición inválida. Escapar es obligatorio cuando el origen del texto no es de confianza.

Contar y localizar todas las coincidencias

A veces no basta con saber que existe una coincidencia; hay que contarlas o recorrerlas todas. indexOf() acepta una posición de inicio, así que puedes repetirlo avanzando tras cada hallazgo.

function contarApariciones(texto, fragmento) {
  if (fragmento === "") return 0;

  let total = 0;
  let posicion = texto.indexOf(fragmento);

  while (posicion !== -1) {
    total += 1;
    posicion = texto.indexOf(fragmento, posicion + fragmento.length);
  }

  return total;
}

console.log(contarApariciones("la casa de la loma", "la")); // 2
console.log(contarApariciones("aaaa", "aa"));               // 2
2
2

Fíjate en la comprobación de la cadena vacía al inicio. Sin ella el bucle sería infinito, porque indexOf("") siempre devuelve una posición válida y avanzar cero caracteres nunca termina.

Con expresiones regulares la misma tarea es más breve:

const total = ("la casa de la loma".match(/la/g) || []).length;
console.log(total); // 2
2

La alternativa con || [] es necesaria porque match() devuelve null cuando no hay coincidencias, y acceder a length de null provocaría un error.

Trampas habituales y cómo evitarlas

Algunos problemas se repiten una y otra vez en revisiones de código. Conocerlos de antemano ahorra horas de depuración.

Valores que no son cadenas

Los métodos de cadena existen en String.prototype, así que llamarlos sobre undefined o null lanza un TypeError. Es común cuando el dato proviene de una API o de un formulario.

const descripcion = undefined;

// Falla: Cannot read properties of undefined
// descripcion.includes("oferta");

// Opción segura con encadenamiento opcional
console.log(descripcion?.includes("oferta")); // undefined

// Con valor por defecto
console.log((descripcion ?? "").includes("oferta")); // false
undefined
false

La segunda variante devuelve siempre un booleano, lo que suele ser preferible en condiciones y filtros. Con números, el método tampoco existe: si tienes 12345, primero conviértelo con String(valor).

La cadena vacía siempre coincide

Una búsqueda con cadena vacía devuelve true en includes() y 0 en indexOf(), porque la cadena vacía está contenida en cualquier texto. En un buscador esto es bueno, ya que un campo vacío muestra todos los resultados, pero en una validación puede abrir una puerta inesperada.

console.log("cualquier cosa".includes(""));  // true
console.log("cualquier cosa".indexOf(""));   // 0
true
0

Si tu lógica no debe aceptar entradas vacías, valídalas antes con una comprobación explícita.

Caracteres Unicode y emojis

Las cadenas de JavaScript se almacenan como unidades de 16 bits. Un emoji o ciertos caracteres poco comunes ocupan dos unidades, lo que afecta a las posiciones devueltas por indexOf() y a la longitud. Para buscar, includes() funciona correctamente con estos caracteres, pero si cortas el texto con índices puedes partir un carácter por la mitad.

const frase = "Listo 🚀 para lanzar";

console.log(frase.includes("🚀")); // true
console.log(frase.indexOf("🚀"));  // 6
console.log("🚀".length);          // 2
true
6
2

Si necesitas tratar los caracteres como unidades visibles, usa Array.from(cadena) o Intl.Segmenter, que respetan los límites de grafemas.

Comparar con acentos distintos que parecen iguales

Un mismo carácter puede representarse como una sola unidad o como una letra más una marca combinada. Visualmente son idénticos, pero la búsqueda literal los trata como distintos. Aplicar normalize() a ambos textos antes de comparar soluciona el problema.

const compuesta = "é";      // é en una sola unidad
const descompuesta = "é";  // e más acento combinado

console.log(compuesta === descompuesta);                          // false
console.log(compuesta.normalize() === descompuesta.normalize());  // true
false
true

Rendimiento y elección del método

Para cadenas de tamaño normal, la diferencia de rendimiento entre includes() e indexOf() es irrelevante: ambos están muy optimizados en los motores actuales. La elección debe basarse en la claridad. Aun así, hay criterios útiles cuando trabajas con volúmenes grandes.

  • Evita crear una expresión regular dentro de un bucle si el patrón no cambia; defínela una vez fuera y reutilízala.
  • Si buscas muchas veces dentro del mismo texto enorme, valora si necesitas un índice o una estructura distinta, como un conjunto de palabras ya separadas.
  • Normaliza el texto una sola vez, no en cada comparación, cuando filtres listas largas.
  • Con la bandera g en una expresión regular reutilizada, test() conserva el estado en lastIndex, lo que produce resultados alternos sorprendentes.

Este último punto genera bastante confusión, así que merece un ejemplo.

const patron = /abc/g;

console.log(patron.test("abc")); // true
console.log(patron.test("abc")); // false, continúa tras la primera coincidencia
console.log(patron.test("abc")); // true
true
false
true

Si solo quieres saber si existe una coincidencia, evita la bandera g con test(). Y para la normalización previa en listas grandes, hazlo así:

const catalogo = [
  "Teclado mecánico",
  "Ratón inalámbrico",
  "Monitor curvo",
].map((nombre) => ({ nombre, clave: limpiar(nombre) }));

function buscar(consulta) {
  const q = limpiar(consulta);
  return catalogo.filter((p) => p.clave.includes(q));
}

console.log(buscar("RATON").map((p) => p.nombre)); // [ 'Ratón inalámbrico' ]
[ 'Ratón inalámbrico' ]

La limpieza se calcula una sola vez por elemento y no en cada pulsación de tecla, lo que se nota en catálogos de miles de entradas.

Un caso completo: filtro de logs

Para juntar lo aprendido, construyamos una pequeña utilidad que lee líneas de un registro y las clasifica. Usa startsWith() para el nivel, includes() para palabras clave, una expresión regular para extraer un identificador y indexOf() para cortar el mensaje.

const lineas = [
  "WARN  [pagos] reintento de cobro id=A-1042",
  "ERROR [pagos] tarjeta rechazada id=B-2210",
  "INFO  [envios] paquete listo id=C-3333",
  "ERROR [envios] dirección inválida id=D-4000",
];

const reId = /id=([A-Z]-\d+)/;

function analizar(linea) {
  const nivel = linea.startsWith("ERROR")
    ? "error"
    : linea.startsWith("WARN")
    ? "aviso"
    : "info";

  const modulo = linea.slice(linea.indexOf("[") + 1, linea.indexOf("]"));
  const coincidencia = reId.exec(linea);

  return {
    nivel,
    modulo,
    id: coincidencia ? coincidencia[1] : null,
    esDePagos: linea.includes("[pagos]"),
  };
}

const resultado = lineas.map(analizar).filter((r) => r.nivel === "error");
console.log(resultado);
[
  { nivel: 'error', modulo: 'pagos', id: 'B-2210', esDePagos: true },
  { nivel: 'error', modulo: 'envios', id: 'D-4000', esDePagos: false }
]

Observa cómo cada método ocupa el lugar donde resulta más natural. No hay un único método ganador; la habilidad está en combinarlos según la necesidad.

Cómo elegir el método adecuado

Una guía rápida para decidir sin darle demasiadas vueltas:

  • Solo quieres saber si un fragmento está en el texto: usa includes().
  • Necesitas la posición para cortar o extraer: usa indexOf() o lastIndexOf().
  • Te importa el comienzo o el final: usa startsWith() o endsWith().
  • Debes ignorar mayúsculas y la búsqueda es literal: normaliza con toLowerCase() y usa includes().
  • Necesitas un patrón, alternativas o límites de palabra: usa expresiones regulares con test(), match() o matchAll().
  • El dato puede ser nulo: protege con ?. o con ?? "" antes de llamar al método.

Si quieres profundizar en alguno de estos temas, puedes consultar nuestro artículo sobre cómo usar includes para buscar cadenas en JavaScript, donde se repasa el método con otros escenarios. Para dominar los patrones, te resultará útil el tutorial de expresiones regulares en JavaScript, y si después de localizar un fragmento quieres sustituirlo, revisa cómo usar replaceAll para reemplazar texto.

Pruebas rápidas para asegurar tu código

Una buena costumbre es acompañar las funciones de búsqueda con pruebas pequeñas que cubran los casos límite: mayúsculas, cadena vacía, valores nulos y acentos. Con el ejecutor de pruebas integrado en Node.js no necesitas instalar nada.

import { test } from "node:test";
import assert from "node:assert/strict";

function contieneSinDistinguir(texto, fragmento) {
  return (texto ?? "").toLowerCase().includes(fragmento.toLowerCase());
}

test("ignora mayúsculas", () => {
  assert.equal(contieneSinDistinguir("Hola Mundo", "mundo"), true);
});

test("tolera valores nulos", () => {
  assert.equal(contieneSinDistinguir(null, "x"), false);
});

test("la cadena vacía siempre coincide", () => {
  assert.equal(contieneSinDistinguir("abc", ""), true);
});
✔ ignora mayúsculas
✔ tolera valores nulos
✔ la cadena vacía siempre coincide

Ejecuta el archivo con node --test y verás el resultado en la terminal. Dejar documentado el comportamiento ante entradas extrañas es lo que evita regresiones cuando alguien modifique la función dentro de unos meses.

Conclusiones

Comprobar si una cadena contiene otra es una operación sencilla, pero con matices que conviene dominar. includes() es la elección por defecto cuando solo necesitas un sí o un no, porque su nombre describe exactamente lo que hace y devuelve un booleano limpio. indexOf() y lastIndexOf() siguen siendo valiosos cuando la posición forma parte del problema, siempre comparando con -1 para no caer en la trampa del índice cero.

Para búsquedas más precisas, startsWith() y endsWith() reducen los falsos positivos, y para ignorar mayúsculas basta con normalizar ambos textos, añadiendo normalize() si hay acentos de por medio. Las expresiones regulares quedan reservadas para patrones reales, recordando escapar la entrada del usuario y evitar la bandera g cuando solo se quiere un test() puntual.

Por último, proteger los valores nulos antes de llamar a cualquier método y probar los casos límite con pequeñas pruebas automáticas te dará código mucho más fiable. Con estas herramientas y criterios podrás resolver cualquier búsqueda de texto en JavaScript con la solución más clara y menos propensa a errores.