在Chrome36上用Javascript循环此数组的最快方法

我有一个非常大的数组，看起来像这样

var counts = ["gfdg 34243","jhfj 543554",....] //55268 elements long

这是我当前的循环

var replace = "";
var scored = 0;
var qgram = "";
var score1 = 0;
var len = counts.length;

function score(pplaintext1) {
    qgram = pplaintext1;
    for (var x = 0; x < qgram.length; x++) {
        for (var a = 0, len = counts.length; a < len; a++) {
            if (qgram.substring(x, x + 4) === counts[a].substring(0, 4)) {
                replace = parseInt(counts[a].replace(/[^1-9]/g, ""));
                scored += Math.log(replace / len) * Math.LOG10E;
            } else {
                scored += Math.log(1 / len) * Math.LOG10E;
            }
        }
    }
    score1 = scored;
    scored = 0;
} //need to call the function 1000 times roughly

var replace=”“；
var得分=0；
var qgram=“”；
var评分1=0；
var len=计数。长度；
功能评分（pplaintext1）{
qgram=pplaintext1；
对于（变量x=0；x

---

我必须在这个数组中循环几次，我的代码运行得很慢。我的问题是，在这个数组中循环的最快方法是什么，这样我就可以节省尽可能多的时间。

您的

计数数组似乎是一个唯一字符串和与它们相关联的值的列表。改为使用对象，键入唯一字符串，例如：

var counts = { gfdg: 34243, jhfj: 543554, ... };

通过将
O（1）
对象键查找替换为
O（n）
内部循环，这将极大地提高性能

另外，避免分割-
log（1/n）=-log（n）
-并将循环不变量移到循环之外。您的
log（1/len）*Math.LOG10E
实际上是在每次传递中添加的一个常量，除了在第一个
if
分支中，您还需要考虑
Math.log（replace）
，这在log Math中意味着添加它

p、 也要避免使用外部范围的状态变量作为分数！我认为以下内容正确地复制了您的评分算法：

var len = Object.keys(counts).length;

function score(text) {
    var result = 0;
    var factor = -Math.log(len) * Math.LOG10E;

    for (var x = 0, n = text.length - 4; x < n; ++x) {
        var qgram = text.substring(x, x + 4);
        var replace = counts[qgram];
        if (replace) {
            result += Math.log(replace) + factor;
        } else {
            result += len * factor;  // once for each ngram
        }
    }
    return result;
}

var len=Object.keys（counts）.length；
功能评分（文本）{
var结果=0；
var因子=-Math.log（len）*Math.LOG10E；
对于（变量x=0，n=text.length-4；x
您的
计数
数组似乎是唯一字符串及其关联值的列表。改为使用对象，键入唯一字符串，例如：

var counts = { gfdg: 34243, jhfj: 543554, ... };

通过将
O（1）
对象键查找替换为
O（n）
内部循环，这将极大地提高性能

另外，避免分割-
log（1/n）=-log（n）
-并将循环不变量移到循环之外。您的
log（1/len）*Math.LOG10E
实际上是在每次传递中添加的一个常量，除了在第一个
if
分支中，您还需要考虑
Math.log（replace）
，这在log Math中意味着添加它

p、 也要避免使用外部范围的状态变量作为分数！我认为以下内容正确地复制了您的评分算法：

var len = Object.keys(counts).length;

function score(text) {
    var result = 0;
    var factor = -Math.log(len) * Math.LOG10E;

    for (var x = 0, n = text.length - 4; x < n; ++x) {
        var qgram = text.substring(x, x + 4);
        var replace = counts[qgram];
        if (replace) {
            result += Math.log(replace) + factor;
        } else {
            result += len * factor;  // once for each ngram
        }
    }
    return result;
}

var len=Object.keys（counts）.length；
功能评分（文本）{
var结果=0；
var因子=-Math.log（len）*Math.LOG10E；
对于（变量x=0，n=text.length-4；x
您的
计数
数组似乎是唯一字符串及其关联值的列表。改为使用对象，键入唯一字符串，例如：

var counts = { gfdg: 34243, jhfj: 543554, ... };

通过将
O（1）
对象键查找替换为
O（n）
内部循环，这将极大地提高性能

另外，避免分割-
log（1/n）=-log（n）
-并将循环不变量移到循环之外。您的
log（1/len）*Math.LOG10E
实际上是在每次传递中添加的一个常量，除了在第一个
if
分支中，您还需要考虑
Math.log（replace）
，这在log Math中意味着添加它

p、 也要避免使用外部范围的状态变量作为分数！我认为以下内容正确地复制了您的评分算法：

var len = Object.keys(counts).length;

function score(text) {
    var result = 0;
    var factor = -Math.log(len) * Math.LOG10E;

    for (var x = 0, n = text.length - 4; x < n; ++x) {
        var qgram = text.substring(x, x + 4);
        var replace = counts[qgram];
        if (replace) {
            result += Math.log(replace) + factor;
        } else {
            result += len * factor;  // once for each ngram
        }
    }
    return result;
}

var len=Object.keys（counts）.length；
功能评分（文本）{
var结果=0；
var因子=-Math.log（len）*Math.LOG10E；
对于（变量x=0，n=text.length-4；x
您的
计数
数组似乎是唯一字符串及其关联值的列表。改为使用对象，键入唯一字符串，例如：

var counts = { gfdg: 34243, jhfj: 543554, ... };

通过将
O（1）
对象键查找替换为
O（n）
内部循环，这将极大地提高性能

另外，避免分割-
log（1/n）=-log（n）
-并将循环不变量移到循环之外。您的
log（1/len）*Math.LOG10E
实际上是在每次传递中添加的一个常量，除了在第一个
if
分支中，您还需要考虑
Math.log（replace）
，这在log Math中意味着添加它

p、 也要避免使用外部范围的状态变量作为分数！我认为以下内容正确地复制了您的评分算法：

var len = Object.keys(counts).length;

function score(text) {
    var result = 0;
    var factor = -Math.log(len) * Math.LOG10E;

    for (var x = 0, n = text.length - 4; x < n; ++x) {
        var qgram = text.substring(x, x + 4);
        var replace = counts[qgram];
        if (replace) {
            result += Math.log(replace) + factor;
        } else {
            result += len * factor;  // once for each ngram
        }
    }
    return result;
}

var len=Object.keys（counts）.length；
功能评分（文本）{
var结果=0；
var因子=-Math.log（len）*Math.LOG10E；
对于（变量x=0，n=text.length-4；x