5

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

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

无论如何可以在几秒钟内实现（过滤）这个？

4

7 回答 7

3

如果没有任何样本数据，我们将无法做太多事情，但概括地说，这就是我看待解决方案的方式

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
                });
            }
        }
    }
}
于 2013-06-06T08:26:14.630 回答
1

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

你可以做一件事。根据你的情况(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 值”新数组（不要忘记在 Id 匹配时放置一个中断）。

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

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

于 2013-06-06T08:18:15.923 回答
1

首先，您可以按 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
    }
  }
}
于 2013-06-06T08:35:48.383 回答
1

这类似于 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
    });
  }
}

注意：显然，我还没有实际测试过代码，但理论上这应该可以工作，除非我遗漏了一些东西。

于 2013-06-06T08:40:11.087 回答
1 
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
                      });
                }

             }

            }
        }

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

于 2013-06-06T08:26:01.143 回答
1

您可以通过使用 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
            });
    }
}

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

于 2013-06-06T08:38:01.183 回答
0

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

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;
                    }
                }
            }
        }
    }
于 2013-06-06T08:26:59.200 回答