Javascript Performance: How come looping through an array and checking every value is faster than indexOf, search and match?

This came as a huge surprise for me, and I’d like to understand this result. I made a test in jsperf that is basically supposed to take a string (that is part of a URL that I’d like to check) and checks for the presence of 4 items (that are in fact, present in the string).

It checks in 5 ways:

  • Issues with indexOf and lastIndexOf on substring - Get Part of URL from string
  • How can I correctly check if a string does NOT contain a specific word?
  • Meet a strange phenomenon of JavaScript Array.indexOf (in Node.js)
  • document.location.indexOf is not a function
  • Matching value of an array regardless of position in javascript
  • Uncaught TypeError: .indexOf is not a function
    1. plain indexOf;
    2. Split the string, then indexOf;
    3. regex search;
    4. regex match;
    5. Split the string, loop through the array of items, and then check if any of them matches the things it’s supposed to match

    To my huge surprise, number 5 is the fastest in Chrome 21. This is what I can’t explain.

    In Firefox 14, the plain indexOf is the fastest, that one I can believe.

  • Is there an indexOf in javascript to search an array with custom compare function
  • How to find indexOf element in jQuery array?
  • IE11 error, Object doesn't support property or method 'defineProperty'
  • How to use IndexOf in JQuery
  • Time Complexity of javascript indexOf method
  • Get value of a string after a slash in JavaScript
  • 2 Solutions collect form web for “Javascript Performance: How come looping through an array and checking every value is faster than indexOf, search and match?”

    I’m also surprised but Chrome uses v8, a highly optimized JavaScript engine which pulls all kinds of tricks. And the guys at Google probably have the largest set of JavaScript to run to test the performance of their implementation. So my guess is this happens:

    1. The compiler notices that the array is a string array (type can be determine at compile time, no runtime checks necessary).
    2. In the loop, since you use ===, builtin CPU op codes to compare strings (repe cmpsb) can be used. So no functions are being called (unlike in any other test case)
    3. After the first loop, everything important (the array, the strings to compare against) is in CPU caches. Locality rulez them all.

    All the other approaches need to invoke functions and locality might be an issue for the regexp versions because they build a parse tree.

    I have added two more tests : http://jsperf.com/finding-components-of-a-url/2

    The single regExp is fastest now (on Chrome). Also regExp literals are faster than string literals converted to RegExp.