Javascript 数组的复杂问题

我有一个复杂的问题需要解决。
我有一个如下所示的数组：

var array = [
             ["1hszZhsez7", 0, "mb12", 0],
             ["87hJKLi893", 1, "tt43", 0],
             ["jchd79dcic", 1, "tt43", 2],
             ["as0w9ejasm", 1, "tt43", 1],
             ["coosihchw9", 0, "zz00", 0],
             ["vs0x0j9ndm", 1, "uu33", 0],
             ["00s0kd20r7", 1, "uu33", 2],
             ["xassdwddao", 1, "uu33", 1],
             ["caosw8ncxc", 2, "uu33", 0]
            ];   

var type_zero = [
                 ["coosihchw9", 0, "zz00", 0]
                ];   

var type_one = [
                 ["87hJKLi893", 1, "tt43", 0],
                 ["jchd79dcic", 1, "tt43", 2],
                 ["as0w9ejasm", 1, "tt43", 1],
                 ["vs0x0j9ndm", 1, "uu33", 0],
                 ["00s0kd20r7", 1, "uu33", 2],
                 ["xassdwddao", 1, "uu33", 1]
                ];  
 
var type_two = [
                 ["caosw8ncxc", 2, "uu33", 0]
                ];  

for (let type of Object.keys(results)) {
  for (let code of Object.keys(results[type])) {
    const array = results[type][code];
  }
}

此数组始终具有不同的值。那我们进去吧。
该数组基本上具有以下值：

var array = [
             [id, type, code, priority]
            ];      

id:该id是唯一的。没什么特别的。
类型：有三种不同的类型。0、1和2。
代码：代码不是唯一的。对于多个数组项，它可以是相同的。
优先级：优先级是一个数字。如果数字较低，则优先级较高。如果数量较大，则优先级较低

---

任务：
首先，我们需要将不同的类型排序到不同的数组中。所以它看起来像这样：

var array = [
             ["1hszZhsez7", 0, "mb12", 0],
             ["87hJKLi893", 1, "tt43", 0],
             ["jchd79dcic", 1, "tt43", 2],
             ["as0w9ejasm", 1, "tt43", 1],
             ["coosihchw9", 0, "zz00", 0],
             ["vs0x0j9ndm", 1, "uu33", 0],
             ["00s0kd20r7", 1, "uu33", 2],
             ["xassdwddao", 1, "uu33", 1],
             ["caosw8ncxc", 2, "uu33", 0]
            ];   

var type_zero = [
                 ["coosihchw9", 0, "zz00", 0]
                ];   

var type_one = [
                 ["87hJKLi893", 1, "tt43", 0],
                 ["jchd79dcic", 1, "tt43", 2],
                 ["as0w9ejasm", 1, "tt43", 1],
                 ["vs0x0j9ndm", 1, "uu33", 0],
                 ["00s0kd20r7", 1, "uu33", 2],
                 ["xassdwddao", 1, "uu33", 1]
                ];  
 
var type_two = [
                 ["caosw8ncxc", 2, "uu33", 0]
                ];  

for (let type of Object.keys(results)) {
  for (let code of Object.keys(results[type])) {
    const array = results[type][code];
  }
}

使用此功能很容易：

 array.forEach(function(item) {
      if (item[1] === 0) {
        type_zero.push([item[0], item[1], item[2], item[3], item[4], item[5]]);
      }
      else if (item[1] === 1) {
        type_one.push([item[0], item[1], item[2], item[3], item[4], item[5]]);
      }
      else if (item[1] === 2) {
        type_two.push([item[0], item[1], item[2], item[3], item[4], item[5]]);
      }
    });     

但接着头痛开始了。我们需要为每个代码组创建一个单独的数组。但我们永远不知道有多少不同的代码。所以我们不能制作静态数组。
不管我们使用哪种代码。最后，它应该是这样的，基于我们的示例数组

var type_zero_zz00 = [
                      ["coosihchw9", 0, "zz00", 0]
                     ];

var type_one_tt43 = [
                      ["87hJKLi893", 1, "tt43", 0],
                      ["jchd79dcic", 1, "tt43", 2],
                      ["as0w9ejasm", 1, "tt43", 1],
                     ];

 var type_one_uu33 = [
                      ["vs0x0j9ndm", 1, "uu33", 0],
                      ["00s0kd20r7", 1, "uu33", 2],
                      ["xassdwddao", 1, "uu33", 1]
                     ];
      
 var type_two_uu33 = [
                      ["caosw8ncxc", 2, "uu33", 0]
                     ];  

为什么我需要这些阵列？在下一步中，我必须为每个数组列表执行forEach循环。我希望有人知道一个解决方案，因为这个问题耗费了很多天的时间，不可能的想法越来越大。
提前感谢，

---

Marius

我知道你所需要的只是创建函数来获取你需要的信息，而不是创建很多不同的变量

const results = {
  0: {},
  1: {},
  2: {},
};

for (let item of array) {
  let [id, type, code, priority] = item;

  if (results[type][code] === undefined) {
    results[type][code] = [item];
  } else {
    results[type][code] = results[type][code].concat([item]);
  }
}

下面是你需要做什么的想法，而不是你所需要的100%准确的版本

var数组=[
[“1hszZhsez7”，0，“mb12”，0]，
[“87hJKLi893”，1，“tt43”，0]，
[“jchd79dcic”，1，“tt43”，2]，
[“as0w9ejasm”，1，“tt43”，1]，
[“coosihchw9”，0，“zz00”，0]，
[“vs0x0j9ndm”，1，“uu33”，0]，
[“00s0kd20r7”，1，“uu33”，2]，
[“xassdwddao”，1，“uu33”，1]，
[“caosw8ncxc”，2，“uu33”，0]
];   
函数getByCode（代码）{
返回数组.filter（项=>项[1]==代码）；
}
函数getByGroup（组）{
返回数组.filter（项=>项[2]==组）；
}

您可以使用单个数组，只需将代码用作数组索引即可

var输出=[]；
变量数组=[
[“1hszZhsez7”，0，“mb12”，0]，
[“87hJKLi893”，1，“tt43”，0]，
[“jchd79dcic”，1，“tt43”，2]，
[“as0w9ejasm”，1，“tt43”，1]，
[“coosihchw9”，0，“zz00”，0]，
[“vs0x0j9ndm”，1，“uu33”，0]，
[“00s0kd20r7”，1，“uu33”，2]，
[“xassdwddao”，1，“uu33”，1]，
[“caosw8ncxc”，2，“uu33”，0]
];
array.forEach（函数（项）{
if（输出[项目[1]]==未定义）{
输出[项目[1]]=[]
}
输出[项目[1]]。推送（项目）；
});
console.log（0，输出[0]）
console.log（1，输出[1]）
log（2，输出[2]）

使用二维dict怎么样？通过这样做，您将得到如下数据结构，您可以为类型和代码组添加新值（它们本身就是DICT）：

var type = {};
type["0"]["zz00"] = [
                  ["coosihchw9", 0, "zz00", 0]
                 ];
type["1"]["tt43"] = [
                  ["87hJKLi893", 1, "tt43", 0],
                  ["jchd79dcic", 1, "tt43", 2],
                  ["as0w9ejasm", 1, "tt43", 1],
                 ];

type["1"]["uu33"] = [
                  ["vs0x0j9ndm", 1, "uu33", 0],
                  ["00s0kd20r7", 1, "uu33", 2],
                  ["xassdwddao", 1, "uu33", 1]
                 ];
  
type["2"]["uu33"] = [
                  ["caosw8ncxc", 2, "uu33", 0]
                 ];  

---

创建处理动态代码的映射：

function groupArray(arr) {
  const map = {};
  arr.forEach(element => {
    const [id, type, code, priority] = element;
    map[code] = Array.isArray(map[code]) ? [...map[code], element] : [element];
  });
  return map;
}

const type_zero_group = groupArray(type_zero)
const type_one_group = groupArray(type_one)
const type_two_group = groupArray(type_two)

---

现在，如果类型本身变得动态，那么也为它们创建一个映射器。两级映射。

不是为每个类型和代码组合创建新变量，而是为每个组合创建一个具有属性的对象。现在，这实际上是一个简单的按两个键分组的问题。您可以使用

Array.reduce（）

和生成对象或贴图：

常量数组=[[“1hszZhsez7”，0，“mb12”，0]，“87hJKLi893”，1，“tt43”，0]，“jchd79dcic”，1，“tt43”，2]，“as0w9ejasm”，1，“tt43”，1]，“coosihchw9”，0，“zz00”，0]，“vs0j9ndm”，1，“uuuu33”，0]，“00s0kd20r7”，1，“uuuu33”，2]，“xassdwddao”，1，“uuu33”，1]，“caosw8ncxc”，2，“uuu33”，0]；
常量类型=['0'，'1'，'2']；
const result=array.reduce（（r，行）=>{
常量[，类型，代码]=行；
const key=`type_${types[type]}{code}`；
如果（！r[key]）r[key]=[]；
r[键]。按（行）；
返回r；
}, {});
控制台日志（结果）
.as console wrapper{max height:100%！important；top:0；}
您可以构建这样的对象来解决问题，而不是尝试生成许多变量

const results = {
  0: {},
  1: {},
  2: {},
};

for (let item of array) {
  let [id, type, code, priority] = item;

  if (results[type][code] === undefined) {
    results[type][code] = [item];
  } else {
    results[type][code] = results[type][code].concat([item]);
  }
}

然后，您可以像这样映射这些对象：

var array = [
             ["1hszZhsez7", 0, "mb12", 0],
             ["87hJKLi893", 1, "tt43", 0],
             ["jchd79dcic", 1, "tt43", 2],
             ["as0w9ejasm", 1, "tt43", 1],
             ["coosihchw9", 0, "zz00", 0],
             ["vs0x0j9ndm", 1, "uu33", 0],
             ["00s0kd20r7", 1, "uu33", 2],
             ["xassdwddao", 1, "uu33", 1],
             ["caosw8ncxc", 2, "uu33", 0]
            ];   

var type_zero = [
                 ["coosihchw9", 0, "zz00", 0]
                ];   

var type_one = [
                 ["87hJKLi893", 1, "tt43", 0],
                 ["jchd79dcic", 1, "tt43", 2],
                 ["as0w9ejasm", 1, "tt43", 1],
                 ["vs0x0j9ndm", 1, "uu33", 0],
                 ["00s0kd20r7", 1, "uu33", 2],
                 ["xassdwddao", 1, "uu33", 1]
                ];  
 
var type_two = [
                 ["caosw8ncxc", 2, "uu33", 0]
                ];  

for (let type of Object.keys(results)) {
  for (let code of Object.keys(results[type])) {
    const array = results[type][code];
  }
}

您可以使用
reduce
方法和对象作为累加器来执行此操作，您可以使用该累加器通过
键入code
作为键对值进行分组


var数组=[
[“1hszZhsez7”，0，“mb12”，0]，
[“87hJKLi893”，1，“tt43”，0]，
[“jchd79dcic”，1，“tt43”，2]，
[“as0w9ejasm”，1，“tt43”，1]，
[“coosihchw9”，0，“zz00”，0]，
[“vs0x0j9ndm”，1，“uu33”，0]，
[“00s0kd20r7”，1，“uu33”，2]，
[“xassdwddao”，1，“uu33”，1]，
[“caosw8ncxc”，2，“uu33”，0]
];
const result=array.reduce（（r，e）=>{
常量[id、类型、代码、优先级]=e；
const key=`${type}|${code}`；
如果（！r[key]）{
r[键]=[]
}
r[键]。按下（e）；
返回r；
}, {})
console.log（Object.values（result））
请添加问题所在。您需要分组算法还是允许分组的数据结构？