Question 54610 in Javascript Question posted in
A very good W3school tutorial can be found here.

is String.includes faster than String.search? – Javascript

word.includes(str) returns a boolean indicating whether or not str is included in word
word.search(str) returns a number representing the position of the first str found in word, -1 if it does not exist.

At first, I wondered why JavaScript provides both, however it’s possible to create only one method that works for both cases, returns position else returns undefined, but since both exist, so it should be for a reason, maybe String.includes is faster, or maybe, it’s just to make things clearer.

It looks like String.includes should be faster as it only checks if str exists rather than trying to find its position, however, my simple thought: to check if str exists in word the algorithm should loop through the word characters anyway (if there is something I’m missing let me know) and once str is found, it can easily retrieve its position, so String.includes couldn’t be faster.

I want to know the real difference between them and why both exist. thank you!

Tags:

2

Answers


  1. 0

    The big difference between the two is that search() takes a regex – much more flexible and (probably) slower than the match in includes() that can be done quickly with something like boyer-moore

    The companion to includes() is indexOf() which is probably very comparable algorithmically. With that pair, it could make sense to build includes() as a bool-returning wrapper around indexOf().

    Login or Signup to reply.
  2. 0

    String.prototype.includes() is basically a convenience method which just uses String.prototype.indexOf(). They both accept a string argument and an optional (start) position argument. They try to find a matching substring value inside the string.

    String.prototype.search() is then better compared to String.prototype.indexOf() because they both return the index of the matched content.
    .search() works differently because it performs a regex search, while .indexOf() just tries to find the exact substring.

    Thus it’s easy to conclude that .search() must always be slower than .indexOf(), and therefore slower than .contains(), because checking if a substring is equal to a value is slower than checking if a substring matches a regex rule.

    Login or Signup to reply.
Please signup or login to give your own answer.

Back To Top
Search