JavaScript: compruebe si la cadena contiene una subcadena

Verificar si una cadena contiene una subcadena es una operación común y difiere ligeramente entre idiomas. JavaScript ofrece varias formas de hacer esto.

Una operación común en muchos lenguajes de programación es verificar si una cadena contiene otra cadena. Si bien es una tarea simple y común, los nombres de los métodos a menudo difieren entre los lenguajes de programación. Por ejemplo, aquí hay una pequeña muestra de los métodos utilizados para lograr esto en varios idiomas:

  • Java: String.contains(), String.indexOf(), etc.
  • Python: operador in, String.index(), String.find()
  • Ir: cadenas.Contiene()
  • Ruby: cadena.incluir?

Tú entiendes. Hay un millón de formas de hacer esto, y parece que cada idioma lo implementa de manera diferente.

De todos modos, veamos algunas de las formas en que puede verificar si una cadena contiene una subcadena en JavaScript.

Nota: Los dos primeros métodos que se muestran a continuación también funcionan en arreglos, lo que le indica si un arreglo contiene un valor dado (o el índice del mismo para indexOf()). Tenga esto en cuenta cuando lea el artículo, ya que probablemente lo ayudará en casos de uso similares.

El método String.includes()

Este método se introdujo en ES6 y suele ser el método preferido para casos de uso simples. Si todo lo que necesita hacer es obtener un valor booleano que indique si la subcadena está en otra cadena, entonces esto es lo que querrá usar.

Funciona así:

1
2
3
4
> let str = 'wikihtp';
> let substr = 'stack';
> str.includes(substr);
true

Como puede ver, se devuelve un valor booleano ya que la cadena "stack" es una subcadena de "wikihtp".

Esta es una búsqueda que distingue entre mayúsculas y minúsculas, por lo que lo siguiente no coincidirá con la subcadena:

1
2
3
4
> let str = 'wikihtp';
> let substr = 'stack';
> str.includes(substr);
false

Si bien esto es suficiente para la mayoría de los casos de uso, el método includes() también proporciona otra opción que puede resultarle útil. Se puede proporcionar un segundo argumento que le dice al método en qué índice comenzar la búsqueda. Entonces, si sabe que la subcadena no está contenida en los primeros 50 caracteres (o simplemente no quiere que coincida con esos caracteres), entonces puede usar el método como este:

1
str.includes(substr, 50);

Un desplazamiento de por debajo de 0 simplemente inicia la búsqueda desde el índice 0, y un desplazamiento mayor que string.length devuelve false ya que la búsqueda comienza desde string.length.

El método String.indexOf()

El método String.indexOf() es muy parecido al método anterior includes() (y también es adecuado para usarse en un polyfill para includes()), pero la única diferencia es el retorno valor. En lugar de devolver un valor booleano que indica la presencia de la subcadena, en realidad devuelve la ubicación del índice de la subcadena, o -1 si no está presente.

Aquí hay un ejemplo:

1
2
3
4
5
6
> let str = 'wikihtp';
> let substr = 'abuse';
> str.indexOf(substr);
5
> str.indexOf('apple');
-1

Como puede ver, este método devuelve la posición de índice basada en 0 de la subcadena y un -1 cuando no se encontró la subcadena.

Al igual que el método includes(), el método indexOf() distingue entre mayúsculas y minúsculas y también es compatible con el parámetro de desplazamiento:

1
2
3
4
5
6
7
8
> let str = 'wikihtp';
> let substr = 'abuse';
> str.indexOf(substr);
-1
> str.indexOf('Abu', 3);
5
> str.indexOf('Abu', 6);
-1

Este método es útil cuando necesita saber la ubicación exacta de la subcadena, sin embargo, no es tan limpio cuando simplemente se usa como un valor booleano:

1
2
3
4
5
6
let str = 'wikihtp';
let substr = 'stack';

if (str.indexOf(substr) > -1) {
    console.log('Found the substring!');
}

En casos como este, deberías usar el método includes() en su lugar, ya que es más propenso a errores.

expresión regular

Una de las formas más útiles y poderosas de verificar una subcadena es usar expresiones regulares o regex. El uso de expresiones regulares para una tarea como esta le brinda mucha más flexibilidad que con los métodos anteriores en los que solo puede verificar una cadena constante. Si bien la expresión regular es un tema demasiado amplio para cubrirlo por completo aquí, al menos podemos echar un vistazo a algunas de las características útiles para nuestro caso de uso.

La verificación de subcadenas en una cadena con expresiones regulares se puede lograr usando el método RegExp.test ():

1
2
3
> let str = 'wikihtp';
> /stack/.test(str);
true

A diferencia de los dos métodos anteriores, ahora podemos hacer búsquedas que no distinguen entre mayúsculas y minúsculas con el indicador i:

1
2
3
> let str = 'wikihtp';
> /stack/i.test(str);
true

Como un ejemplo más complejo, digamos que desea ver si una cadena contiene un código postal (códigos postales de 5 dígitos), pero realmente no le importa qué código postal hay en la cadena. Este tipo de problema no se puede resolver usando includes() o indexOf(). Pero con expresiones regulares, podemos probar esto fácilmente:

1
2
3
4
5
6
> let str = 'My zip code is 90210';
> /\d{5}/.test(str);
true
> str = 'My address is 123 Fake St.';
> /\d{5}/.test(str);
false

Si bien JavaScript no es necesariamente conocido por su velocidad, tenga en cuenta que será más lento que un método más simple como includes(), por lo que solo debe usarlo para los casos más complejos que no se pueden resolver. con una solución más sencilla.

Conclusión

La manipulación e inspección de cadenas es una de las tareas más comunes que se realizan en muchos lenguajes de programación, especialmente con código orientado al usuario. Por muchas razones diferentes, como la validación de cadenas, deberá verificar si una cadena contiene una subcadena. En este artículo, vimos algunos métodos diferentes provistos por JavaScript que le permiten hacer exactamente eso. o.