Javascript 防止；“停止运行脚本”；加载大量数据时

我目前正在运行2个for循环，遍历2个对象数组，并使用两个列表中出现的对象创建一个新数组。当列表变大时，我会得到一个“停止运行脚本”提示

MineGlobals.receivedData=jQuery.parseJSON（MineGlobals.receivedDataRaw）；
MineGlobals.nettstatsjonslist=新数组（）；
var len1=MineGlobals.nsData.length；
变量len2=MineGlobals.receivedData.nettstatsjoner.length
对于（变量i=0；i

我尝试使用setTimeout（），但无法使其工作。。。有什么想法吗

编辑

因此，由于我是一个新用户，我无法回答自己的问题，但我设法找到了解决方案。我使用了AssociateArray（）。在其中放置最大的数组，ID作为键，然后在其上迭代以查找相同的ID

var associativeArray = {};
for (var i = 0; i < len1; i++) {
    associativeArray[MineGlobals.nsData[i].Id] = MineGlobals.nsData[i];
}

 for (var j = 0; j < len2; j++) {
    var obj = new nsObject();
    obj = associativeArray[MineGlobals.receivedData.Nettstasjoner[j].Id];
    if (obj != undefined) {
        if (obj.Lg != 0 && obj.La != 0) {
            if (obj == null || obj == "") {
                obj.Nvn = "Ikke definert";
            }
            if (obj.NisAdresse == null || obj.NisAdresse == "") {
                obj.NisAdresse = "Ikke definert";
            }
            MineGlobals.nettStasjonsListe.push(obj);
        }
    }
}

var associateArray={}；
对于（变量i=0；i

您可以

区块

数组处理，请参见以下内容：

我围绕它编写了一个原型类，它解决了我在这方面的问题：

/**
 * provides UI update while using large arrays without blocking
 * found core idea on http://www.mattsnider.com/javascript/handle-slow-processes-without-blocking-the-ui/
 */
var ChunkedArray = Class.create(Enumerable, {
    initialize: function(options) {
        this.array = new Array();
        this.options = Object.extend({
            chunkSize: 20,
            interval: 10
        }, options || {})
    },

    push: function(obj) {
        this.array.push(obj)
    },

    chunk: function(array, index, length, iterator, context) {
        var j, l = array.length;
        for (j = (index + length); (index < j && index < l); index += 1) {
            iterator.call(context, array[index], index);
        }

        if (l > index) {
            setTimeout(function() {
                this.chunk(array, index, length, iterator, context);
            }.bind(this), this.options.interval);
        }
    },

    _each: function(iterator, context) {
        this.chunk(this.array, 0,
                this.options.chunkSize, iterator, context);
    },

    toString: function() {
        return this.array.toString();
    }
});

/**
*在使用大型阵列时提供UI更新，无需阻塞
*找到了关于http://www.mattsnider.com/javascript/handle-slow-processes-without-blocking-the-ui/
*/
var ChunkedArray=Class.create（可枚举{
初始化：函数（选项）{
this.array=新数组（）；
this.options=Object.extend({
大小：20，
间隔时间：10
}，选项|{}）
},
推送：功能（obj）{
this.array.push（obj）
},
块：函数（数组、索引、长度、迭代器、上下文）{
var j，l=数组长度；
对于（j=（索引+长度）；（索引索引）{
setTimeout（函数（）{
chunk（数组、索引、长度、迭代器、上下文）；
}.bind（this）、this.options.interval）；
}
},
_each：函数（迭代器、上下文）{
this.chunk（this.array，0，
this.options.chunkSize、迭代器、上下文）；
},
toString:function（）{
返回此.array.toString（）；
}
});

您正在将阵列构建为两个大阵列的乘积？结果数组/矩阵的预期大小（以字节为单位）是多少？你确定你的问题与内存无关吗？我尝试了setTimeout（）。。。怎样？使用异步处理队列是解决此问题的一种方法。或者网络工作者……这可能没有多大帮助，但你可以尝试一下。对于循环，您可以尝试执行相反的操作，而不是执行增量循环

for（var j=len1；j>0；j--）

。特别是在这种情况下，您有两个大for循环。其中一个数组中的对象是否保证按Id排序？如果是，则使用二进制搜索算法

/**
 * provides UI update while using large arrays without blocking
 * found core idea on http://www.mattsnider.com/javascript/handle-slow-processes-without-blocking-the-ui/
 */
var ChunkedArray = Class.create(Enumerable, {
    initialize: function(options) {
        this.array = new Array();
        this.options = Object.extend({
            chunkSize: 20,
            interval: 10
        }, options || {})
    },

    push: function(obj) {
        this.array.push(obj)
    },

    chunk: function(array, index, length, iterator, context) {
        var j, l = array.length;
        for (j = (index + length); (index < j && index < l); index += 1) {
            iterator.call(context, array[index], index);
        }

        if (l > index) {
            setTimeout(function() {
                this.chunk(array, index, length, iterator, context);
            }.bind(this), this.options.interval);
        }
    },

    _each: function(iterator, context) {
        this.chunk(this.array, 0,
                this.options.chunkSize, iterator, context);
    },

    toString: function() {
        return this.array.toString();
    }
});