Javascript计数发生次数

我有以下数组数据，我正在使用includes条件计算匹配的记录数

var final = 
[
  [
    "61131",
    "NISSAN",
    "BOLTON",
    "MAINT"
  ],
  [
    "61132",
    "NISSAN",
    "BOLTON",
    "MAINT"
  ],
  [
    "61133",
    "TOYOTA",
    "STOCKPORT",
    "STORED"
  ],
  [
    "61134",
    "TOYOTA",
    "STOCKPORT",
    "MAINT"
  ],
  [
    "61135",
    "NISSAN",
    "STOCKPORT",
    "MAINT"
  ],
  [
    "61136",
    "NISSAN",
    null,
    null
  ]
]

代码是这样的：

var obj = {};
var num1 = 0;
var num2 = 0;
for (var i=0; i<final.length; i++){
    if(final[i].join(';').includes('BOLTON') && final[i].join(';').includes('MAINT') && final[i].join(';').includes('NISSAN')) {
        num1++;
    }
}

for (var i=0; i<final.length; i++){
    if(final[i].join(';').includes('STOCKPORT') && final[i].join(';').includes('STORED') && final[i].join(';').includes('TOYOTA')) {
        num2++;
    }
}


obj['BOLTON_MAINT_NISSAN'] = num1
obj['STOCKPORT_STORED_TOYOTA'] = num2

console.log(obj)

我得到了期望的结果，是否有一种更有效的方法来编写上述代码，而且是最小的？

不需要使用String.join。数组还具有函数Array.prototype.includes，用于检查数组中是否存在项

使用它，可以找到满足条件的子阵列。 使用Array.prototype.filter，可以提取子数组以满足以下条件

最终常数=[ [61131，日产，博尔顿，缅因州]， [61132，日产，博尔顿，缅因州]， [61133，丰田，斯托克波特，仓库]， [61134，丰田，斯托克波特，缅因州]， [61135，日产，斯托克波特，缅因州]， [61136，日产，零，零] ]; const num1Arr=final.filteritem=>item.包括'BOLTON'和&item.包括'MAINT'和&item.包括'NISSAN'； const num2Arr=final.filteritem=>item。包括'STOCKPORT'和&item。包括'STORED'和&item。包括'TOYOTA'； 常量输出={ 博尔顿日产：平均长度， STOCKPORT_储存_TOYOTA:num2Arr.length }; console.logoutput 最终常数= [ [ 61131, 日产， 博尔顿， 维护 ], [ 61132, 日产， 博尔顿， 维护 ], [ 61133, 丰田 斯托克波特， 存储 ], [ 61134, 丰田 斯托克波特， 维护 ], [ 61135, 日产， 斯托克波特， 维护 ], [ 61136, 日产， 无效的 无效的 ] ]; console.log{ BOLTON_MAINT_日产：final.filtervalue=>{ 返回值[1]=“日产”和&value[2]=“博尔顿”和&value[3]=“MAINT”； }.长度， STOCKPORT_存储_TOYOTA:final.filtervalue=>{ 返回值[1]=“TOYOTA”和值[2]=“STOCKPORT”和值[3]=“STORED”； }.长度， };常量计数=列表，键=>{ 返回键。减少 obj，key=>{ …obj， [键]：list.filterPublist=> key.split'.everykeyPart=>sublist.includeskeyPart 长 }, {} ; }; countfinal，['BOLTON_MAINT_NISSAN'、'STOCKPORT_STORED_TOYOTA'] 最终常数=[ [61131，日产，博尔顿，缅因州]， [61132，日产，博尔顿，缅因州]， [61133，丰田，斯托克波特，仓库]， [61134，丰田，斯托克波特，缅因州]， [61135，日产，斯托克波特，缅因州]， [61136，日产，零，零] ]; 常量计数=列表，键=>{ 返回键。减少 obj，key=>{ …obj， [键]：list.filterPublist=> key.split'.everykeyPart=>sublist.includeskeyPart 长 }, {} ; }; var bmtNsst=countfinal，['BOLTON_MAINT_NISSAN'、'STOCKPORT_STORED_TOYOTA']；

---

console.logbmtNsst 使用reduce、slice去除数字、filter去除空值，并使用join使其成为键

var最终=[ [61131，日产，博尔顿，缅因州]， [61132，日产，博尔顿，缅因州]， [61133，丰田，斯托克波特，仓库]， [61134，丰田，斯托克波特，缅因州]， [61135，日产，斯托克波特，缅因州]， [61136，日产，零，零] ]; var分组=final.reducefunctionobj，数据{ var key=data.slice1.filterBoolean.join\ux； obj[key]=obj[key]| | 0+1； 返回obj； }, {}; console.loggroup使用：

最终常数=[ [61131，日产，博尔顿，缅因州]， [61132，日产，博尔顿，缅因州]， [61133，丰田，斯托克波特，仓库]， [61134，丰田，斯托克波特，缅因州]， [61135，日产，斯托克波特，缅因州]， [61136，日产，零，零] ]; let occurrence=final.reduceobj，item=>{ 变量键=项目[2]++项目[3]++项目[1]； 如果！obj[key]obj[key]=0； obj[键]+； 返回obj； },{};

---

主控台；发生 在您的解决方案中，您在数组中迭代两次，这是不必要的，因为如果一个对象是您正在搜索的两个对象之一，那么它就不是另一个，因此您可以在一个循环中完成所有操作

var最终=[ [61131，日产，博尔顿，缅因州]， [61132，日产，博尔顿，缅因州]， [61133，丰田，斯托克波特，仓库]， [61134，丰田，斯托克波特，缅因州]， [61135，日产，斯托克波特，缅因州]， [61136，日产，零，零] ]; var obj={ 波顿日产：0， STOCKPORT_存储_丰田：0 }; final.forEachy=>{ 让x=y.连接“；”； ifx.包括“博尔顿”&& x、 包括“维护”&& x、 包括“日产” BOLTON_MAINT_NISSAN++； 否则如果 x、 包括“斯托克波特”&& x、 包括“存储”&& x、 包括“丰田” TOYOTA++； }

---

console.logobj绝对不是最有效的。考虑最后[ i]。总是返回相同的东西，但是在数组中每个元素的运行次数是六次6次。考虑使用Delphi，在你每次加入检查的时候，代码是非常低效的。看起来数组中有位置数据。也就是说，零件号总是出现在第一个位置，制造商日产或丰田总是出现在第二个位置，等等。你可能不需要使用。加入

  {  "BOLTON_MAINT_NISSAN": 2, "STOCKPORT_STORED_TOYOTA": 1}