261

I'm working with a performance issue on JavaScript. So I just want to ask: what is the fastest way to check whether a string contains another substring (I just need the boolean value)? Could you please suggest your idea and sample snippet code?

Improve this question
4

10 Answers 10

Reset to default
419

You have three possibilites:

  1. Regular expression:

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

  2. indexOf:

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

  3. includes:

     str.includes('word')

Regular expressions seem to be faster (at least in Chrome 10).

Performance test - short haystack
Performance test - long haystack

**Update 2011:**

It cannot be said with certainty which method is faster. The differences between the browsers is enormous. While in Chrome 10 indexOf seems to be faster, in Safari 5, indexOf is clearly slower than any other method.

You have to see and try for your self. It depends on your needs. For example a case-insensitive search is way faster with regular expressions.

Update 2018:

Just to save people from running the tests themselves, here are the current results for most common browsers, the percentages indicate performance increase over the next fastest result (which varies between browsers):

Chrome: indexOf (~98% faster) <-- wow
Firefox: cached RegExp (~18% faster)
IE11: cached RegExp(~10% faster)
Edge: indexOf (~18% faster)
Safari: cached RegExp(~0.4% faster)

Note that cached RegExp is: var r = new RegExp('simple'); var c = r.test(str); as opposed to: /simple/.test(str)

Improve this answer
Sign up to request clarification or add additional context in comments.

16 Comments

This may be a little faster only if the text-to-search-for is known before hand (i.e. not stored in a variable) because the regex is created by the JavaScript engine during parse time. If you want to search for a string contained in a variable inside another string variable, indexOf is the fastest because you'd need to create a RegExp object and process the string to escape special characters etc.
from experience, indexOf can be faster for case-insensitive search if you use .toLowerCase on whatever you're searching first
I'm writing an Office 2013 App, using Microsoft's Office Javascript API, and using indexOf doesn't work. I'm not sure why. Using Regex though does. This is an edge case, but others might run into the same issue.
Any reason substr() is not one of the possible solutions? I'd guess it's a lot faster than the RegEx solution in many situations. I don't know how it compares to indexOf() though (so if you left it out because it always performs worse than indexOf() then that's fine, maybe add a note to that effect.) EDIT: this JSperf link shows some interesting results. Short version: indexOf() is the fastest of all methods, but this may vary based on string length and any repeating patterns.
@Bison: you can only use substr if you already know where to look. I focused only on generic solutions.
|
61

The Fastest

  1. (ES6) includes
    var string = "hello",
    substring = "lo";
    string.includes(substring);
  1. ES5 and older indexOf
    var string = "hello",
    substring = "lo";
    string.indexOf(substring) !== -1;

http://jsben.ch/9cwLJ

enter image description here

Improve this answer

Comments

20

Does this work for you?

string1.indexOf(string2) >= 0

Edit: This may not be faster than a RegExp if the string2 contains repeated patterns. On some browsers, indexOf may be much slower than RegExp. See comments.

Edit 2: RegExp may be faster than indexOf when the strings are very long and/or contain repeated patterns. See comments and @Felix's answer.

Improve this answer

6 Comments

but how does this compare to other methods? Is this the fastest, or is it just one of the many methods of doing so?
This should be fast since it is implemented by JavaScript itself (i.e. it runs native code). Any other method based on JavaScript code will be slower. If you know the exact string, a regex might be a bit faster (as the JavaScript engine does not have to walk the prototype chain to find .indexOf).
If you need case-insensitive search, then you'd definitely need to build a RegExp object and call test.
Just ran a test in Safari. indexOf is a magnitude slower than any other method. So it actually cannot be said which method is faster. It varies from browser to browser.
@Felix, that's a good observation (never trust anything until you actually try it yourself)! I vague remembering something that says in strings with lots of repeated patterns, regex's should perform faster than a simple loop comparison implementation because regex's are compiled into state machines and it can back-track much quicker than simple loops -- which has to always back-track to the next character. +1 for doing the experiment and bringing this out!
|
10

In ES6, the includes() method is used to determine whether one string may be found within another string, returning true or false as appropriate.

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

Here is jsperf between 

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

And 

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

As the result shown in jsperf, it seems both of them perform well.

Improve this answer

3 Comments

Can I use "regex" inside, as includes' argument? Like: str.includes("x|y"); search for the literals "x" or "y" in the same call.
@Patrick, Per the include doc, you cannot use regex in it. One work around for your question, str.includes("x") || str.includes('y')
As a result of the Chrome 59 JavaScript improvements, indexOf is significantly faster than includes (upwards of 1600% faster). It's unclear how a difference of 44 million iterations/sec and 777+ million i/sec affects real-world performance, however mobile likely benefits enough that indexOf should be the ideal choice.
7

I've found that using a simple for loop, iterating over all elements in the string and comparing using charAt performs faster than indexOf or Regex. The code and proof is available at JSPerf.

ETA: indexOf and charAt both perform similarly terrible on Chrome Mobile according to Browser Scope data listed on jsperf.com

Improve this answer

5 Comments

Strange that a hand made function is better than a built in one, but I guess this is because the needle is only one character. Still...
Tested in Chrome Mobile 36.0.1985.57 on Apple iPad (iOS 7.1.1). IndexOf is faster. Sorry
@rpax CharAt is still significantly faster on all platforms (based on the history from jsperf) except for Chrome Mobile, where both IndexOf and CharAt equally perform very poorly compared to the desktop.
I'd like to see how this performs in NodeJS, and also this isn't really a good example because you are only looking for one character vs a substring.
This isn't a valid answer at all. You are not searching for a substring, only the occurrence of one single character
5

It's easy way to use .match() method to 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)));

Wish you a nice day, sir!

Improve this answer

1 Comment

No reason to match when there's a test method… Check out the top answer.
3

For finding a simple string, using the indexOf() method and using regex is pretty much the same: http://jsperf.com/substring - so choose which ever one that seems easier to write.

Improve this answer

Comments

3

I made a jsben.ch for you http://jsben.ch/#/aWxtF ...seems that indexOf is a bit faster.

Improve this answer

2 Comments

I forked that to made a more robust test. In Firefox I found less than 1% difference between methods, but on Chrome, indexOf murdered the competition, over 500% faster.
I wonder if there is much difference between a boolean test and != -1
3

2022 string research benchmark

From Felix Kling's answer, and with tests I've done with given links.

Most used browser :

  1. Chrome (64%)
  2. Safari (19%)
  3. New Edge (4%)
  4. Firefox (3.26%)
  5. Samsung (2.86%)
  6. Opera (2.12%)

Chrome and NE are both based on Chromium => same performances.

ci = case insensitive
/ = same as left

Tests results

string length Firefox Safari Chromium
short cached RegExp ci cached RegExp ci indexOf & / ci worth
RegExp & / ci RegExp ci RegExp & / ci worse
long cached RegExp cached RE & / ci & reg ci indexOf worth
indexOf ci indexOf ci RegExp worse

Operations/sec comparison

browser Firefox Safari Chromium
cached RegExp 1.3M 425k 1.2M
diff 1.08x >
cached RegExp case sensitive 28M 31M 42M
diff 1.44/1.35x >
indexOf 27M 25M 1.9B
diff 70/76x >
indexOf case sensitive 13.8M 18.5M 1.9B
diff 137/103x >

Firefox best method : cached regexp case insensitive
Chrome best method : indexOf / indexOf case insensitive
Safari best method : cached RegExp case insensitive

Chrome has widely better performances than the two others.

Best compromise : indexOf : String.indexOf(substring) > -1.

Note : Remind that if you want to use the indexOf case sensitive way, if you operate a String.toLowerCase(), it adds some operations, so it's pretty similar to the insensitive way. In that case, you should be lowering your substring before the search process, not in it.

Regexes are really good for complex and/or pattern research/replacement, but not for a global research, and that in all languages, because of what it is.

Improve this answer

2 Comments

this one lacks the includes tests
Indeed. Apparently, from other posts on SO, the includes method is similar to the indexOf, works the same way and has similar performances, because it uses indexOf underneath.
0

According to this site, include is much faster https://www.measurethat.net/Benchmarks/Show/13675/0/regextest-vs-stringincludes-vs-stringmatch

Improve this answer

1 Comment

but includes() does not support the regex

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.