0

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!

Ahmed Sbai
  • 10,695
  • 9
  • 19
  • 38
  • 1
    Does [this](https://stackoverflow.com/a/54303099) answer your question? It includes a comparison of numerous methods to search a string. (`string.search` is also intended to be used with regular expressions) – grimsteel Mar 18 '23 at 02:21
  • it does not sorry – Ahmed Sbai Mar 18 '23 at 02:24
  • "[I]t's possible to create only one method that works for both cases, returns position else returns undefined" No; a function returns undefined if a value was not returned ([MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined)) and therefore using `undefined` as a return value is unconventional. – InSync Mar 18 '23 at 02:24
  • "*it's possible to create only one method that works for both cases*" - sure that's possible, but it would be awkward to use. You'd have to write `if (word.something(str) != undefined)` all the time. Just as weird as, but even longer than, the existing `if (word.indexOf(str) > -1)` or `if (word.search(regex) > -1)`. That's why `if (word.includes(str))` was created - for convenience and clarity. It has more to do with the speed of the developer writing, reading and understanding the code, than with the speed of the string search algorithm. – Bergi Mar 18 '23 at 02:35
  • `if (word.something(str))` would react the same to it returning undefined (str not found) and it returning 0 (str at start of word). That's why you'd need the explicit `!= undefined` check. – James Mar 18 '23 at 02:44
  • yes you are right – Ahmed Sbai Mar 18 '23 at 02:49
  • 1
    @AhmedSbai No you don't write `array.find(…)`, unless you actually want to get the value back (and `undefined` if not found). If you just want to know whether the value exists, you use `array.some(…)` which appropriately returns a boolean. – Bergi Mar 18 '23 at 03:03

2 Answers2

6

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().

danh
  • 62,181
  • 10
  • 95
  • 136
  • 1
    Note that `.search()` also accepts [anything with a `@@search` method](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/search). – InSync Mar 18 '23 at 02:26
  • `includes()` and `indexOf()` speeds are fairly similar. it just use cases that are different. – Layhout Mar 18 '23 at 02:49
2

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.

ErroneousFatality
  • 450
  • 1
  • 5
  • 13