Najszybszy sposób sprawdzenia, czy ciąg zawiera inny podciąg w JavaScript?

Pracuję z problemem wydajności w JavaScript. Chcę tylko zapytać: jaki jest najszybszy sposób sprawdzenia, czy ciąg zawiera inny podciąg (potrzebuję tylko wartości logicznej)? Czy mógłbyś zasugerować swój pomysł i przykładowy fragment kodu?

Masz dwie możliwości:

1. Wyrażenie regularne :

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

2. indexOf:

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

Wyrażenia regularne wydają się być szybsze (przynajmniej w Chrome 10).

Test wydajności - krótki stóg siana
Test wydajności - długi stóg siana

Nie można z całą pewnością stwierdzić, która metoda jest szybsza. Różnice między przeglądarkami są ogromne. Podczas gdy w Chrome 10 indexOfwydaje się być szybszy, w Safari 5 indexOfjest wyraźnie wolniejszy niż jakakolwiek inna metoda.

Musisz zobaczyć i spróbować samemu. To zależy od Twoich potrzeb. Na przykład wyszukiwanie bez rozróżniania wielkości liter jest znacznie szybsze w przypadku wyrażeń regularnych.

Aktualizacja 2018:

Aby uchronić ludzi przed samodzielnym przeprowadzaniem testów, oto aktualne wyniki dla większości popularnych przeglądarek, wartości procentowe wskazują wzrost wydajności w stosunku do następnego najszybszego wyniku (który różni się w zależności od przeglądarki):

Chrome: indexOf (~ 98% szybciej) <-- wow
Firefox: buforowany RegExp (~ 18% szybciej)
IE11: buforowany RegExp (~ 10% szybciej)
Edge: indexOf (~ 18% szybciej)
Safari: buforowany RegExp (~ 0,4% szybciej)

Zauważ, że buforowane wyrażenie RegExp to: var r = new RegExp('simple'); var c = r.test(str);w przeciwieństwie do:/simple/.test(str)

Czy to działa dla Ciebie?

string1.indexOf(string2) >= 0

Edycja: może to nie być szybsze niż RegExp, jeśli ciąg 2 zawiera powtarzające się wzorce. W niektórych przeglądarkach indexOf może działać znacznie wolniej niż RegExp. Zobacz komentarze.

Edycja 2: RegExp może być szybsze niż indexOf, gdy ciągi są bardzo długie i / lub zawierają powtarzające się wzorce. Zobacz komentarze i odpowiedź @ Felix.

Najszybszy

1. (ES6) obejmuje

    var string = "witaj",
    substring = "lo";
    string.includes (podciąg);

2. ES5 i starsze wersje indexOf

    var string = "witaj",
    substring = "lo";
    string.indexOf (podciąg)! == -1;

http://jsben.ch/9cwLJ

W ES6 includes()metoda jest używana do określenia, czy jeden ciąg można znaleźć w innym ciągu, zwracając truelub falseodpowiednio.

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

Tutaj jest jsperf pomiędzy

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

I

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

Jak widać w jsperf, wydaje się, że oba działają dobrze.

Zauważyłem, że używanie prostej pętli for, iterowanie po wszystkich elementach ciągu i porównywanie za pomocą charAtdziała szybciej niż indexOflub Regex. Kod i dowód są dostępne w JSPerf .

ETA: indexOfi charAtoba działają podobnie strasznie w Chrome Mobile zgodnie z danymi zakresu przeglądarki wymienionymi na jsperf.com

Aby znaleźć prosty łańcuch, użycie metody indexOf () i użycie wyrażenia regularnego jest prawie takie samo: http://jsperf.com/substring - wybierz więc ten, który wydaje się łatwiejszy do napisania.

Zrobiłem dla ciebie jsben.ch http://jsben.ch/#/aWxtF ... wydaje się, że indexOf jest trochę szybszy.

Jest to łatwy sposób na użycie .match()metody do stringów.

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

Życzę miłego dnia, sir!