A maneira mais rápida de verificar uma string contém outra substring em JavaScript?

Estou trabalhando com um problema de desempenho em JavaScript. Então, eu só quero perguntar: qual é a maneira mais rápida de verificar se uma string contém outra substring (eu só preciso do valor booleano)? Você poderia sugerir sua ideia e ter um exemplo de código de trecho?

Você tem duas possibilidades:

1. Expressão regular :

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

2. indexOf:

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

Expressões regulares parecem ser mais rápidas (pelo menos no Chrome 10).

Teste de desempenho - palheiro curto
Teste de desempenho - palheiro longo

Não se pode dizer com certeza qual método é mais rápido. As diferenças entre os navegadores são enormes. Enquanto no Chrome 10 indexOfparece ser mais rápido, no Safari 5, indexOfé claramente mais lento que qualquer outro método.

Você tem que ver e tentar por si mesmo. Isso depende de suas necessidades. Por exemplo, uma pesquisa que não diferencia maiúsculas de minúsculas é muito mais rápida com expressões regulares.

Atualização 2018:

Apenas para evitar que as pessoas executem os testes, aqui estão os resultados atuais dos navegadores mais comuns, as porcentagens indicam um aumento de desempenho em relação ao próximo resultado mais rápido (que varia entre os navegadores):

Chrome: indexOf (~ 98% mais rápido) <-- wow
Firefox: RegExp em cache (~ 18% mais rápido)
IE11: RegExp em cache (~ 10% mais rápido)
Edge: indexOf (~ 18% mais rápido)
Safari: RegExp em cache (~ 0.4% mais rápido)

Observe que o RegExp em cache é: var r = new RegExp('simple'); var c = r.test(str);ao contrário de:/simple/.test(str)

Isso funciona para você?

string1.indexOf(string2) >= 0

Editar: isso pode não ser mais rápido que um RegExp se a string2 contiver padrões repetidos. Em alguns navegadores, indexOf pode ser muito mais lento que o RegExp. Ver comentários.

Edit 2: RegExp pode ser mais rápido que indexOf quando as strings são muito longas e / ou contêm padrões repetidos. Veja os comentários e a resposta de @ Felix.

O mais rápido

1. (ES6) inclui

    var string = "olá",
    substring = "lo";
    string.includes (substring);

2. ES5 e mais velhos indexOf

    var string = "olá",
    substring = "lo";
    string.indexOf (substring)! == -1;

http://jsben.ch/9cwLJ

No ES6, o includes()método é usado para determinar se uma sequência pode ser encontrada dentro de outra, retornando trueou falseconforme apropriado.

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

Aqui está jsperf entre

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

E

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

Como o resultado mostrado no jsperf, parece que os dois apresentam bom desempenho.

Descobri que usar um loop for simples, iterando sobre todos os elementos da string e comparando o charAtdesempenho é mais rápido que indexOfou Regex. O código e a prova estão disponíveis no JSPerf .

ETA: indexOfe charAtambos têm desempenho semelhante no Chrome Mobile, de acordo com os dados do escopo do navegador listados em jsperf.com

Para encontrar uma string simples, usar o método indexOf () e usar regex é praticamente o mesmo: http://jsperf.com/substring - então escolha qual deles parecer mais fácil de escrever.

Eu fiz um jsben.ch para você http://jsben.ch/#/aWxtF ... parece que indexOf é um pouco mais rápido.

É uma maneira fácil de usar o .match()método para string.

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)));

Desejo-lhe um bom dia, senhor!