我的页面上有一个隐藏字段，用于存储以空格分隔的电子邮件列表。 我最多可以在该字段中包含 500 封电子邮件。

如果给定的电子邮件已存在于该列表中，那么搜索最快的方法是什么？ 我需要循环搜索多封电子邮件

1. 使用 RegEx 查找匹配项

2. 使用 indexOf()

3. 将列表转换为 javascript字典然后 搜索

如果这是完全重复的，请让我知道另一个问题。 谢谢

编辑: 感谢大家的宝贵意见和回答。 基本上我的用户在数据库中有一个电子邮件列表(0-500)。 向用户呈现他自己的联系人列表。 然后用户可以从他的联系人列表中选择一个\多个电子邮件添加到列表中。 我想在客户端确保他没有添加重复的电子邮件。 整个操作由ajax驱动，所以需要jsvascript。

最佳答案

答案是:视情况而定。

• 这取决于您实际想要测量的内容。
• 这取决于您搜索的数量与您搜索的数量之间的关系。
• 这取决于 JavaScript 的实现。不同的实现通常具有根本不同的性能特征。这是“不要过早优化”规则特别适用于交叉实现 JavaScript 的众多原因之一。

...但是如果您要查找的内容比总数少得多，它可能是 String#indexOf 除非您可以创建一次字典并重新使用它(不仅仅是这个循环寻找 X 条目，但 每个 循环寻找 X 条目，我倾向于怀疑这是你的用例)，在这种情况下，构建 500 键字典并使用那个。

我整理了一个 test case on jsperf比较在包含 500 个以空格分隔的唯一条目的字符串中查找五个字符串的结果。请注意，jsperf 页面比较了一些苹果和橘子(我们可以忽略设置的情况以及我们忽略了什么样的设置)，但是 jsperf 对拆分它很痛苦，我决定把它留给读者作为练习。

在我对我实际认为您正在做的事情的测试中，Chrome、Firefox、IE6、IE7 和 IE9 的 String#indexOf 速度最快。 Opera 执行 RegExp 交替 最快。 (请注意，IE6 和 IE7 没有 Array#indexOf；其他有。)如果您可以忽略字典设置时间，那么使用字典无疑是赢家。

这是准备代码:

// ==== Main Setup
var toFind = ["aaaaa100@zzzzz", "aaaaa200@zzzzz", "aaaaa300@zzzzz", "aaaaa400@zzzzz", "aaaaa500@zzzzz"];
var theString = (function() {
 var m, n;

 m = [];
 for (n = 1; n <= 500; ++n) {
  m.push("aaaaa" + n + "@zzzzz");
 }
 return m.join(" ");
})();

// ==== String#indexOf (and RegExp) setup for when we can ignore setup
var preppedString = " " + theString + " ";

// ==== RegExp setup for test case ignoring RegExp setup time
var theRegExp = new RegExp(" (?:" + toFind.join("|") + ") ", "g");

// ==== Dictionary setup for test case ignoring Dictionary setup time
var theDictionary = (function() {
 var dict = {};
 var index;
 var values = theString.split(" ");
 for (index = 0; index < values.length; ++index) {
  dict[values[index]] = true;
 }
 return dict;
})();

// ==== Array setup time for test cases where we ignore array setup time
var theArray = theString.split(" ");

String#indexOf 测试:

var index;
for (index = 0; index < toFind.length; ++index) {
 if (theString.indexOf(toFind[index]) < 0) {
  throw "Error";
 }
}

String#indexOf(忽略设置) 测试，我们忽略了在大字符串两端放置空格的(小)开销:

var index;
for (index = 0; index < toFind.length; ++index) {
 if (preppedString.indexOf(toFind[index]) < 0) {
  throw "Error";
 }
}

RegExp 交替测试:

// Note: In real life, you'd have to escape the values from toFind
// to make sure they didn't have special regexp chars in them
var regexp = new RegExp(" (?:" + toFind.join("|") + ") ", "g");
var match, counter = 0;
var str = " " + theString + " ";
for (match = regexp.exec(str); match; match = regexp.exec(str)) {
 ++counter;
}
if (counter != 5) {
 throw "Error";
}

RegExp 交替(忽略设置) 测试，我们忽略设置 RegExp 对象和在大字符串两端放置空格所需的时间 (我认为这不适用于您的情况，您要查找的地址将是静态的):

var match, counter = 0;
for (match = theRegExp.exec(preppedString); match; match = theRegExp.exec(preppedString)) {
 ++counter;
}
if (counter != 5) {
 throw "Error";
}

字典测试:

var dict = {};
var index;
var values = theString.split(" ");
for (index = 0; index < values.length; ++index) {
 dict[values[index]] = true;
}
for (index = 0; index < toFind.length; ++index) {
 if (!(toFind[index] in dict)) {
  throw "Error";
 }
}

Dictionary (ignore setup) 测试，我们不用担心字典的设置时间；请注意，这与 RegExp 交替(忽略设置) 测试不同，因为它假定整体 列表是不变的:

var index;
for (index = 0; index < toFind.length; ++index) {
 if (!(toFind[index] in theDictionary)) {
  throw "Error";
 }
}

Array#indexOf 测试(请注意，一些非常古老的 JavaScript 实现可能没有 Array#indexOf):

var values = theString.split(" ");
var index;
for (index = 0; index < toFind.length; ++index) {
 if (values.indexOf(toFind[index]) < 0) {
  throw "Error";
 }
}

Array#indexOf(忽略设置) 测试，它像Dictionary(忽略设置) 假设整体 列表是不变的:

var index;
for (index = 0; index < toFind.length; ++index) {
 if (theArray.indexOf(toFind[index]) < 0) {
  throw "Error";
 }
}

关于javascript - 在javascript中搜索字符串的最快方法，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/6321763/