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

Estou trabalhando com um problema de desempenho no 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 código de snippet de amostra?

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


Atualização 2011:

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 indexOf parece 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 sem distinção entre maiúsculas e minúsculas é muito mais rápida com expressões regulares.


Atualização 2018:

Apenas para salvar as pessoas de executar os testes, aqui estão os resultados atuais para os navegadores mais comuns, as porcentagens indicam aumento de desempenho sobre o 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); var r = new RegExp('simple'); var c = r.test(str); em oposição a: /simple/.test(str)

Isso funciona para você?

 string1.indexOf(string2) >= 0 

Edit: 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 @ Felix’s answer.

Descobri que, usando um loop for simples, iterar todos os elementos da string e comparar usando charAt é mais rápido que indexOf ou Regex . O código e a prova estão disponíveis no JSPerf .

ETA: indexOf e charAt desempenho semelhante no Chrome Mobile, de acordo com os dados do escopo do navegador listados em jsperf.com

No ES6, o método includes() é usado para determinar se uma string pode ser encontrada dentro de outra string, retornando true ou false conforme 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 ambos executam bem.

Para encontrar uma string simples, usar o método indexOf () e usar o regex é praticamente o mesmo: http://jsperf.com/substring – então escolha qual delas é 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 método .match() 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!