¿La forma más rápida de comprobar que una cadena contiene otra subcadena en JavaScript?

Estoy trabajando con un problema de rendimiento en JavaScript. Entonces solo quiero preguntar: ¿cuál es la forma más rápida de verificar si una cadena contiene otra subcadena (solo necesito el valor booleano)? ¿Podría sugerir su idea y un fragmento de código de muestra?

Mar 14 '11 15:03 Đinh Hồng Châu

Tienes tres posibilidades:

Expresión regular :

 (new RegExp('word')).test(str)
 // or
 /word/.test(str)

indexOf:
```
 str.indexOf('word') !== -1
```
includes:
```
 str.includes('word')
```

~~Las expresiones regulares parecen ser más rápidas (al menos en Chrome 10).~~

Prueba de rendimiento - pajar corto
Prueba de rendimiento - pajar largo

**Actualización 2011:**

No se puede decir con certeza qué método es más rápido. Las diferencias entre los navegadores son enormes. Mientras que en Chrome 10 indexOfparece ser más rápido, en Safari 5 indexOfes claramente más lento que cualquier otro método.

Tienes que verlo y probarlo por ti mismo. Depende de tus necesidades. Por ejemplo, una búsqueda que no distingue entre mayúsculas y minúsculas es mucho más rápida con expresiones regulares.

Actualización 2018:

Solo para evitar que las personas ejecuten las pruebas por sí mismas, aquí están los resultados actuales para los navegadores más comunes, los porcentajes indican un aumento de rendimiento con respecto al siguiente resultado más rápido (que varía entre navegadores):

Chrome: indexOf (~98 % más rápido) <-- wow
Firefox: RegExp en caché (~18 % más rápido)
IE11: RegExp en caché (~10 % más rápido)
Edge: indexOf (~18 % más rápido)
Safari: RegExp en caché (~0,4 % más rápido)

Tenga en cuenta que la RegExp almacenada en caché es: var r = new RegExp('simple'); var c = r.test(str);a diferencia de:/simple/.test(str)

Mar 14 '2011 08:03 Felix Kling

El más rápido

(ES6) incluye

    var cadena = "hola",
    subcadena = "lo";
    cadena.incluye (subcadena);

ES5 y índice anterior de

    var cadena = "hola",
    subcadena = "lo";
    string.indexOf(subcadena) !== -1;

http://jsben.ch/9cwLJ

ingrese la descripción de la imagen aquí

Jan 22 '2019 07:01 Tính Ngô Quang

¿Esto funciona para tí?

string1.indexOf(string2) >= 0

Editar: Es posible que esto no sea más rápido que una expresión regular si la cadena2 contiene patrones repetidos. En algunos navegadores, indexOf puede ser mucho más lento que RegExp. Ver comentarios.

Edición 2: RegExp puede ser más rápido que indexOf cuando las cadenas son muy largas y/o contienen patrones repetidos. Ver comentarios y la respuesta de @Felix.

Mar 14 '2011 08:03 Stephen Chung

En ES6, el includes()método se utiliza para determinar si una cadena se puede encontrar dentro de otra cadena, regresando trueo falsesegún corresponda.

var str = 'To be, or not to be, that is the question.';

console.log(str.includes('To be'));       // true
console.log(str.includes('question'));    // true
console.log(str.includes('nonexistent')); // false

Aquí está jsperf entre

var ret = str.includes('one');

Y

var ret = (str.indexOf('one') !== -1);

Como se muestra en el resultado en jsperf, parece que ambos funcionan bien.

Feb 23 '2016 08:02 zangw