Question

下面的代码需要很长时间;

var table = new Array();
for(var i =0; i< dtObjects.Rows.length; i++)
        {
            for(var j=0; j< dtColumns.Rows.length; j++)
            {
                for(var k=0; k< dtTypes.Rows.length; k++)
                {
                  if((dtObjects.Rows[i].Id == dtColumns.Rows[j].Id) && (dtColumns.Rows[j].xtype == dtTypes.Rows[k].xtype))  

                      table.push({
                          TableName : dtObjects.Rows[i].Name,
                          Type:  dtObjects.Rows[i].type,
                          ColumName:  dtColumns.Rows[j].Name,
                          DataType: dtTypes.Rows[k].Name,
                          Length : dtColumns.Rows[j].Length
                      });
                }
            }
        }

dtObjects.Rows.length = 900

dtColumns.Rows.length = 1500

dtTypes.Rows.length = 30

无论如何要在几秒钟内完成（过滤）这个过程吗？

Answer 1

在没有任何样本数据的情况下，我们无法做很多事情，但在摘要中，这是我如何看待解决方案

var table = new Array();

var dtObjectMap = {}, dtColumnMap = {};
for (var i = 0; i < dtObjects.Rows.length; i++) {
    dtObjectMap['id-' + dtObjects.Rows[i].Id] = dtObjects.Rows[i];
}

for (var j = 0; j < dtColumns.Rows.length; j++) {
    if (!dtColumnMap[dtColumns.Rows[j].xtype]) {
        dtColumnMap[dtColumns.Rows[j].xtype] = [];
    }
    dtColumnMap[dtColumns.Rows[j].xtype].push(dtColumns.Rows[j]);
}

var dtObject, dtColumn, dtType, dtCXtypes;
for (var k = 0; k < dtTypes.Rows.length; k++) {
    dtType = dtType.Rows[i], dtCXtypes = dtColumnXtypes[dtType.xtype];
    if (dtCXtypes && dtCXtypes.length) {
        for (var l = 0; l < dtCXtypes.length; l++) {
            dtColumn = dtCXtypes[l];
            dtObject = dtObjectMap['id-' + dtColumn.id];
            if (dtObject) {
                table.push({
                    TableName : dtObject.Name,
                    Type : dtObject.type,
                    ColumName : dtColumn.Name,
                    DataType : dtType.Name,
                    Length : dtColumn.Length
                });
            }
        }
    }
}

Answer 2

首先，当你的情况匹配时，你没有休息。匹配条件后无需继续。

你可以做一件事。根据你的条件(dtObjects.Rows[i].Id == dtColumns.Rows[j].Id) && (dtColumns.Rows[j].xtype == dtTypes.Rows[k].xtype)我告诉你这个逻辑。

首先循环dtObjects和dtColumns并检查condtion dtObjects.Rows[i].Id == dtColumns.Rows[j].Id。无论 id匹配，请将“j value”添加到新数组中（不要忘记在ID匹配时暂停）。

完成此循环后。再为newArray和dtTypes循环。以这种方式检查您的状况“dtColumns[newArray[k]].xtype == dtTypes.Rows[l].xtype”

还有一件事，将对象保持为具有更多计数的外循环。

Answer 3

var table = new Array();
for(var i =0; i< dtObjects.Rows.length; i++)
        {
            for(var j=0; j< dtColumns.Rows.length; j++)
            {
                if(dtObjects.Rows[i].Id == dtColumns.Rows[j].Id){
                    for(var k=0; k< dtTypes.Rows.length; k++)
                {
                  if(dtColumns.Rows[j].xtype == dtTypes.Rows[k].xtype) 

                      table.push({
                          TableName : dtObjects.Rows[i].Name,
                          Type:  dtObjects.Rows[i].type,
                          ColumName:  dtColumns.Rows[j].Name,
                          DataType: dtTypes.Rows[k].Name,
                          Length : dtColumns.Rows[j].Length
                      });
                }

             }

            }
        }

我刚刚在你的最后一个循环之前调整了你的第一个条件，这将使它“更快一点”

Answer 4

首先，您可以按ID：

对dtObjects和dtColums进行排序

function sortById(a,b){
  return (a.id>b.id)?1:(a.id<b.id)?-1:0;
}
dtOjbects.Rows.sort(sortById);
dtColumns.Rows.sort(sortById);

var table = new Array(),
j=0,i=0,
colLen=dtColumns.Rows.length,
objLen=dtObjects.Rows.length,
typLen=dtTypes.Rows.length,
tmpMatch=[];
for(i =0; i< objLen; i++){
  while(j<colLen||dtObjects.Rows[i].id>dtColumns.Rows[j].id){
    if(dtObjects.Rows[i].id===dtColumns.Rows[j].id){
      tmpMatch.push([i,j]);
    }
    j++;
  }
}
for(i=0;i<tmpMatch.length;i++){
  for(j=0;j<typLen;j++){
    if(dtColumns.Rows[tmpMatch[i][1]].xtype == dtTypes.Rows[j].xtype){
      table.push({
        TableName : dtObjects.Rows[tmpMatch[i][0]].Name,
        Type:  dtObjects.Rows[tmpMatch[i][0]].type,
        ColumName:  dtColumns.Rows[tmpMatch[i][1]].Name,
        DataType: dtTypes.Rows[j].Name,
        Length : dtColumns.Rows[tmpMatch[i][1]].Length
    }
  }
}

Answer 5

您可以通过使用Id创建索引对象来完成此操作。

var table = new Array(),
    orows = dtObjects.Rows,
    crows = dtColumns.Rows,
    crowsIndex = {},
    types = dtTypes.Rows,
    typesIndex = {};

for (var j = 0; j < crows.length; j++) {
    crowsIndex[crows[j].Id] = crows[j];
}

for (var k = 0; k < types.length; k++) {
    typesIndex[types[k].xtype] = types[k];
}

for (var i = 0; i < orows.length; i++) {
    var rID = orows[i].Id;
    if (crowsIndex[rID]) {
        var xType = crowsIndex[rID].xtype;
        if (typesIndex[xType]) {
            table.push({
                TableName: orows[i].Name,
                Type: orows[i].type,
                ColumName: crowsIndex[rID]].Name,
            DataType: typesIndex[xType].Name,
            Length: crowsIndex[rID].Length
            });
    }
}

这不是测试，可能不是您需要的最终解决方案，但会帮助您开始使用。请提供样本数据进行测试。

Answer 6

这与Arun的答案类似（虽然可能更简单）。

如果你愿意换一点内存来提高速度，你可以做些什么，就是创建一个你要检查的对象的哈希值。

检查哈希中存在的速度要快得多，以便迭代并比较每列，行和列的ID。类型。要利用这一点，您可以从创建两个类型和列集合的哈希开始，然后您只需检查哈希中是否存在。

var table = new Array();
var columnsHash = {};
for(var j=0; j< dtColumns.Rows.length; j++) {
  columnsHash[dtColumns.Rows[j].Id] = dtColumns.Rows[j];
}
var typesHash = {};
for(var k=0; k< dtTypes.Rows.length; k++) {
  typesHash[dtTypes.Rows[k].xtype] = dtTypes.Rows[k];
}

for(var i =0; i< dtObjects.Rows.length; i++) {
  var typesObj, columnObj = columnsHash[dtObjects.Rows[i].Id];
  if (columnObj && (typesObj = typesHash[columnObj.xtype])) {
    table.push({
      TableName : dtObjects.Rows[i].Name,
      Type:  dtObjects.Rows[i].type,
      ColumName:  columnObj.Name,
      DataType: typesObj.Name,
      Length : columnObj.Length
    });
  }
}

注意：显然我没有对代码进行过实际测试，但理论上这应该可行，除非我遗漏了一些内容。

Answer 7

这将提供相当快的速度。我们需要知道每行可能有多少匹配列。如果它只是一个，你也可以在匹配后打破循环。

var table = new Array();

for(var i =0; i< dtObjects.Rows.length; i++)
    {
        for(var j=0; j< dtColumns.Rows.length; j++)
        {
            if(dtObjects.Rows[i].Id == dtColumns.Rows[j].Id)
            {
                for(var k=0; k< dtTypes.Rows.length; k++)
                {

                    if((dtColumns.Rows[j].xtype == dtTypes.Rows[k].xtype))  {
                          table.push({
                          TableName : dtObjects.Rows[i].Name,
                          Type:  dtObjects.Rows[i].type,
                          ColumName:  dtColumns.Rows[j].Name,
                          DataType: dtTypes.Rows[k].Name,
                          Length : dtColumns.Rows[j].Length
                      });
                        break;
                    }
                }
            }
        }
    }

在javascript中过滤数组的有效方法

7 个答案: