在 JavaScript 中检查字符串是否包含另一个子字符串的最快方法？

Question

我正在处理 JavaScript 的性能问题。 所以我只想问：检查一个字符串是否包含另一个子字符串的最快方法是什么（我只需要布尔值）？ 您能否提出您的想法和示例代码段？

Answer 1

你有三种可能：

1. 正则表达式：

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

2. indexOf ：

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

3. includes ：

    str.includes('word')

正则表达式似乎更快（至少在 Chrome 10 中）。

性能测试——短草垛
性能测试——大海捞针

---

**2011 年更新：**

不能肯定地说哪种方法更快。 浏览器之间的差异是巨大的。 虽然在 Chrome 10 中indexOf似乎更快，但在 Safari 5 中， indexOf显然比任何其他方法都慢。

你必须看到并尝试自己。 这取决于您的需求。 例如，不区分大小写的搜索使用正则表达式会更快。

---

2018 年更新：

为了避免人们自己运行测试，以下是大多数常见浏览器的当前结果，百分比表示性能比下一个最快的结果（因浏览器而异）有所提高：

Chrome： indexOf（快 98%） <-- wow
Firefox：缓存 RegExp（快 18%）
IE11：缓存 RegExp（快 10%）
边缘： indexOf（快 18%）
Safari：缓存 RegExp（快 0.4%）

注意缓存的 RegExp是： var r = new RegExp('simple'); var c = r.test(str); var r = new RegExp('simple'); var c = r.test(str); 相对于： /simple/.test(str)

Answer 2

最快的

1. (ES6)包括

var string = "hello",
    substring = "lo";
    string.includes(substring);

2. ES5 及更早的indexOf

var string = "hello",
    substring = "lo";
    string.indexOf(substring) !== -1;

http://jsben.ch/9cwLJ

Answer 3

这对你有用吗？

string1.indexOf(string2) >= 0

编辑：如果 string2 包含重复模式，这可能不会比 RegExp 快。 在某些浏览器上，indexOf 可能比 RegExp 慢得多。 看评论。

编辑 2：当字符串很长和/或包含重复模式时，RegExp 可能比 indexOf 快。 查看评论和@Felix 的回答。

Answer 4

在 ES6 中， includes()方法用于确定一个字符串是否可以在另一个字符串中找到，并根据需要返回true或false 。

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

这里是jsperf之间

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

和

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

正如jsperf中显示的结果，似乎它们都表现良好。

Answer 5

我发现使用简单的 for 循环，迭代字符串中的所有元素并使用charAt进行比较比indexOf或Regex执行得更快。 代码和证明可在JSPerf 获得。

ETA：根据 jsperf.com 上列出的浏览器范围数据， indexOf和charAt在 Chrome Mobile 上的表现同样糟糕

Answer 6

使用.match()方法来.match()是很简单的方法。

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

祝您有美好的一天，先生！

Answer 7

我为你做了一个 jsben.ch http://jsben.ch/#/aWxtF ...似乎 indexOf 快一点。

Answer 8

为了找到一个简单的字符串，使用 indexOf() 方法和使用正则表达式几乎相同： http : //jsperf.com/substring - 所以选择看起来更容易编写的那个。

Answer 9

2022年弦乐研究基准

来自Felix Kling 的回答，以及我对给定链接所做的测试。

最常用的浏览器：

1. 铬 (64%)
2. 野生动物园 (19%)
3. 新优势 (4%)
4. 火狐 (3.26%)
5. 三星 (2.86%)
6. 歌剧 (2.12%)

Chrome 和 NE 都基于 Chromium => 相同的性能。

ci = 不区分大小写
/ = 与左边相同

测试结果

字符串长度	火狐	苹果浏览器	铬
短的	缓存的正则表达式	缓存的正则表达式	indexOf & / ci	值得
	正则表达式 & / ci	正则表达式	正则表达式 & / ci	更差
长	缓存的正则表达式	缓存的 RE & / ci & reg ci	指数	值得
	指数指数	指数指数	正则表达式	更差

操作/秒比较

浏览器	火狐	苹果浏览器	铬
缓存的正则表达式	1.3M	425k	1.2M
差异	1.08x >
缓存的 RegExp 区分大小写	28M	31M	42M
差异			1.44/1.35x >
指数	27M	25M	1.9B
差异			70/76x >
indexOf 区分大小写	13.8M	18.5M	1.9B
差异			137/103x >

Firefox 最佳方法：缓存的正则表达式不区分大小写
Chrome 最佳方法：indexOf / indexOf 不区分大小写
Safari 最佳方法：缓存 RegExp 不区分大小写

Chrome 的性能比其他两个要好得多。

最佳妥协： indexOf : String.indexOf(substring) > -1 。

注意：提醒一下，如果你想使用indexOf case sensitive的方式，如果你操作一个String.toLowerCase() ，它会增加一些操作，所以它和不区分大小写的方式非常相似。 在这种情况下，您应该在搜索过程之前降低子字符串，而不是在其中。

正则表达式确实适用于复杂和/或模式研究/替换，但不适用于全球研究，并且在所有语言中都是如此，因为它是什么。