Javascript 过滤数组的数组

我正在尝试编写一个函数，它接受数组数组作为参数，并在特定条件下过滤该数组。我稍后会解释这种情况。 例如，我有这样的数组：

 const arr = [
  [1, 1, 20],
  [2, 1, 15],
  [3, 1.5, 15],
  [4, 1, 15],
  [5, 1, 20],
  [6, 1.5, 15],
  [7, 1, 25],
  [8, 1, 15],
  [9, 0, 15],
  [10, 0, 15],
  [11, 0, 15],
]

和条件。我想通过第三列的值对其进行过滤，但前提是序列中至少有三列。函数应该接受两个参数（如果需要，可以接受更多）：value和array 比如说

 const filterByValue = (array, val) => { //definition 
     return filtredArr
   }

const newArr=filterByValue（数组，15） 现在，newArr应该等于：

 [
   [2, 1, 15],
   [3, 1.5, 15],
   [4, 1, 15],
   [8, 1, 15],
   [9, 0, 15],
   [10, 0, 15],
   [11, 0, 15],
 ]

目前我只做了以下几点：

const filterByValue = (arr, value) => {
      const newArr = arr.filter((elem, index) => elem[2] === value)
      return newArr
  }

但是这个函数返回

  [
     [2, 1, 15],
     [3, 1.5, 15],
     [4, 1, 15],
     [6, 1.5, 15],
     [8, 1, 15],
     [9, 0, 15],
     [10, 0, 15],
     [11, 0, 15],
  ]

不应该有[6,1.5,15]。我不知道如何才能只返回一行中至少包含三个内部数组的数组片段。也许你们有谁知道

编辑更多解释

---

这个序列对我来说意味着，我只希望输出在第三个值（函数中的值参数）中包含一个集合值的内部数组，但它们也有相互跟随的内部数组（至少三个）。让我们假设函数接受arr（我文章中的第一个数组）和value=15。第一个内部数组包含20作为第三个值，因此它会下降。第二个是okey，第三个也是，第四个也是——在这种情况下，应该返回2,3,4内部董事会（因为他们连续跟随三个）。然后第五个值是20，第六个值是15，但下一个（第七个）值又是25，因此函数不应该考虑第六个表（因为后面没有至少两个值为15的表）。在表8,9,10,11中，我们有值15，这是四个表（即至少三个）。因此，函数应该返回一个数组，其中包含以下表2、3、4和8、9、10、11。第六个数组包含值15，但后面没有两个也包含该值的数组。预期的输出是我文章中的第二块板。

您可以对索引进行闭包，并检查值是否按三个顺序排列。

const filterByValue = (arr,value) => {
    let newArray = [];
    let cache = [];
    arr.forEach(elem => {
        if (elem[2] === value) {
            cache.push(elem);
        } else {
            if (cache.length >= 3) {
                newArray = newArray.concat(cache);
            }
            cache = [];
        }
    });
    if (cache.length >= 3) {
        newArray = newArray.concat(cache);
    }
    return newArray;
}

const
数组=[[1,1,20]，[2,1,15]，[3,1.5,15]，[4,1,15]，[5,1,20]，[6,1.5,15]，[7,1,25]，[8,1,15]，[9,0,15]，[10,0,15]，[11,0,15]，
值=15，
结果=array.filter(
（索引=>（{2:v}，i，a）=>{
如果（v！==值）返回false；
if（index==i | | a[i+1][2]==value&&a[i+2][2]==value）{
指数=i+1；
返回true；
}
})
(-1)
);
控制台日志（结果）尝试使用
过滤器
和基于是否匹配值的条件


const arr=[
[1, 1, 20],
[2, 1, 15],
[3, 1.5, 15],
[4, 1, 15],
[5, 1, 20],
[6, 1.5, 15],
[7, 1, 25],
[8, 1, 15],
[9, 0, 15],
[10, 0, 15],
[11, 0, 15],
];
常量filterByValue=（数组，val）=>
array.filter（（ar，i，items）=>{
if（ar[2]！==val）{
返回true；
}否则{
退货项目[i-1][2]==val | |退货项目[i+1][2]==val；
}
});
日志（filterByValue（arr，15））而不使用缓存阵列

检查元素是否包含数字15如果是，则递增计数器如果计数器至少达到3，则表示可以将这3个元素存储到新列表中。使用当前索引和计数器之间的差值从第一个序列元素到最后一个序列元素。重复此过程，直到到达阵列的末尾


const arr=[
[1, 1, 20],
[2, 1, 15],
[3, 1.5, 15],
[4, 1, 15],
[5, 1, 20],
[6, 1.5, 15],
[7, 1, 25],
[8, 1, 15],
[9, 0, 15],
[10, 0, 15],
[11, 0, 15]
];
设cnt=0；
让列表=[]；
for（设i=0；i=3）{
对于（设j=i-cnt；jconsole.log（list）
我读了你的问题，但我还没有意识到你过滤数组的标准是什么？您是否可以添加一个更好的过滤条件描述和预期输出？序列中的3是什么意思，您是否可以更详细地描述这些条件？2、4、6和3、6、9是否为您的用例提供了一个有效的序列，或者共同的区别必须是1？e、 g.1,2,3（有效的）1,3,4（无效的）2,3,4（有效的），3,6,9（无效的）我编辑了这篇文章以获得更多的解释，谢谢你的关注，下面的一位同事解决了这个问题！这个很好用。而且它非常优雅，我觉得太复杂了。谢谢！！你能解释一下
{2:v}
，因为它在每次迭代中都是一个数组，它是如何工作的吗？在javascript中，数组是对象，这部分使用数组的属性
2
进行解构。基本上它从索引
2
中获取值。是的，我知道数组在js中是对象，但我不知道它可以这样解析，我知道数组的解构使用方括号，你能提供任何关于这方面的参考吗？只是标准的：