¿La forma más rápida de verificar que una cadena contenga 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 código de fragmento de muestra?

Tienes dos posibilidades:

1. Expresión regular :

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

2. indexOf:

   str.indexOf('word') !== -1

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

Prueba de rendimiento: pajar corto
Prueba de rendimiento: pajar largo

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 ver y probar 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 ellos mismos, estos son los resultados actuales para los navegadores más comunes, los porcentajes indican un aumento en el rendimiento sobre el 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 RegExp en caché es: var r = new RegExp('simple'); var c = r.test(str);en lugar de:/simple/.test(str)

¿Esto funciona para tí?

string1.indexOf(string2) >= 0

Editar: Esto puede no ser más rápido que un RegExp 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.

El más rápido

1. (ES6) incluye

    var cadena = "hola",
    substring = "lo";
    string.includes (subcadena);

2. ES5 y el índice anterior

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

http://jsben.ch/9cwLJ

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 jsperf, parece que ambos funcionan bien.

Descubrí que usar un bucle for simple, iterar sobre todos los elementos de la cadena y comparar el uso se charAtrealiza más rápido que indexOfo Regex. El código y la prueba están disponibles en JSPerf .

ETA: indexOfy charAtambos funcionan de manera similar en Chrome Mobile según los datos del alcance del navegador que figuran en jsperf.com

Para encontrar una cadena simple, usar el método indexOf () y usar regex es más o menos lo mismo: http://jsperf.com/substring , así que elija el que parezca más fácil de escribir.

Hice un jsben.ch para ti http://jsben.ch/#/aWxtF ... parece que indexOf es un poco más rápido.

Es una manera fácil de usar el .match()método para encadenar.

var re = /(AND|OR|MAYBE)/;
var str = "IT'S MAYBE BETTER WAY TO USE .MATCH() METHOD TO STRING";
console.log('Do we found something?', Boolean(str.match(re)));

¡Le deseo un buen día, señor!