JavaScript: compruebe si la cadena contiene una subcadena

    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: in operador, String.index(), String.find()
    • Vamos: strings.Contains()
    • Rubí: string.include?

    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 la cadena contiene una subcadena en JavaScript.

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

    los String.includes() Método

    Este método se introdujo en ES6 y suele ser el método preferido para casos de uso sencillos. 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í:

    > let str="Pharos.sh";
    > let substr="stack";
    > str.includes(substr);
    true
    

    Como puede ver, se devuelve un valor booleano ya que la cadena “pila” es una subcadena de “Pharos.sh”.

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

    > let str="Pharos.sh";
    > let substr="stack";
    > str.includes(substr);
    false
    

    Si bien esto es suficiente para la mayoría de los casos de uso, el includes() El método 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 de esta manera:

    str.includes(substr, 50);
    

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

    los String.indexOf() Método

    los String.indexOf() El método es muy parecido al anterior includes() método (y es adecuado para ser utilizado en un polyfill para includes() también), pero la única diferencia es el valor de retorno. 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.

    He aquí un ejemplo:

    > let str="Pharos.sh";
    > 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.

    Como el includes() método, el indexOf() El método distingue entre mayúsculas y minúsculas y también admite el parámetro de compensación:

    > let str="Pharos.sh";
    > let substr="abuse";
    > str.indexOf(substr);
    -1
    > str.indexOf('Abu', 3);
    5
    > str.indexOf('Abu', 6);
    -1
    

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

    let str="Pharos.sh";
    let substr="stack";
    
    if (str.indexOf(substr) > -1) {
        console.log('Found the substring!');
    }
    

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

    Regex

    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, donde solo puede verificar una cadena constante. Si bien la expresión regular es un tema demasiado grande para cubrirlo completamente 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 RegExp.test() método:

    > let str="Pharos.sh";
    > /stack/.test(str);
    true
    

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

    > let str="Pharos.sh";
    > /stack/i.test(str);
    true
    

    Como ejemplo más complejo, digamos que quiere 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:

    > 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 de todos modos, tenga en cuenta que esto 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 simple.

    Conclusión

    Manipular e inspeccionar cadenas es una de las tareas más comunes realizadas en muchos lenguajes de programación, especialmente con código de cara al usuario. Por muchas razones diferentes, como validar cadenas, deberá verificar si una cadena contiene una subcadena. En este artículo, vimos algunos métodos diferentes proporcionados por JavaScript que le permiten hacer exactamente eso.

     

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *