Javascript 角度-如何根据某些特定检查减少阵列？

我有一个从数据库中得到的有序数组，看起来像：

     let myArray = [      
        {month: 1, visible: true},
        {month: 2, visible: false}, 
        {month: 3, visible: true}, 
        {month: 4, visible: false},
        {month: 5, visible: false}, 
        {month: 6, visible: true},
        {month: 7, visible: true},
        {month: 8, visible: false}, 
        {month: 9, visible: true}, 
        {month: 10, visible: false},
        {month: 11, visible: false},
        {month: 12, visible: false}
      ];

我需要做的是将其简化为一个新数组，其中第一个对象将是第一个具有属性的

visible=true

的

month

，然后它将占用具有

month=true

的最后一个对象的所有月份

这意味着，只有当月份不在一个序列中时，它才会忽略月份，所以如果月份没有造成缺口的话

在我上面的示例中，它将返回最后一个

3（10，11，12）

之外的所有对象，因为它们位于序列之外，该序列是由第一个

TRUE

和最后一个

TRUE

创建的（在本例中为

第1个月

和

第9个月

）

我希望我说清楚了，那么我怎样才能完成我的reduce（）

期望输出：

 let myArray = [      
            {month: 1, visible: true},
            {month: 2, visible: false}, 
            {month: 3, visible: true}, 
            {month: 4, visible: false},
            {month: 5, visible: false}, 
            {month: 6, visible: true},
            {month: 7, visible: true},
            {month: 8, visible: false}, 
            {month: 9, visible: true}
];

---

找到起始位置很简单，但找到结束位置有点棘手

我会采取这个方法：

查找具有匹配条件的第一个索引

查找具有匹配条件的最后一个索引

从第一个到最后一个返回切片

演示：

补充阅读 如果您对其中一些技术不熟悉，请阅读以下附加内容：

Javascript等价物 这是没有Typescript杂音的纯javascript等价物

function filterContiguous(arr, predicate) {
  const first = arr.findIndex(predicate);
  if (first === -1) {
    // no matching items in array
    return [];
  }

  let last = first;
  for (let i = arr.length - 1; i >= first; i--) {
    if (predicate(arr[i]) === true) {
      last = i;
      break;
    }
  }

  return arr.slice(first, last + 1);
}

---

找到起始位置很简单，但找到结束位置有点棘手

我会采取这个方法：

查找具有匹配条件的第一个索引

查找具有匹配条件的最后一个索引

从第一个到最后一个返回切片

演示：

补充阅读 如果您对其中一些技术不熟悉，请阅读以下附加内容：

Javascript等价物 这是没有Typescript杂音的纯javascript等价物

function filterContiguous(arr, predicate) {
  const first = arr.findIndex(predicate);
  if (first === -1) {
    // no matching items in array
    return [];
  }

  let last = first;
  for (let i = arr.length - 1; i >= first; i--) {
    if (predicate(arr[i]) === true) {
      last = i;
      break;
    }
  }

  return arr.slice(first, last + 1);
}

---

您可以找到索引，直到您的索引应该被切片，然后只取这个数组：

const findMaxIndex = arr => {
    let prev = 0;
    for (let index = arr.length - 1; index >= 0; index--) {
        prev = index - 1;
        if (arr[index].visible == false && arr[prev].visible !=  false)
          return index;
    }
    return -1;
};

console.log(myArray.slice(0, findMaxIndex(myArray)));

例如：

让myArray=[
{月份：1，可见：真}，
{月份：2，可见：false}，
{月份：3，可见：真}，
{月份：4，可见：false}，
{月份：5，可见：false}，
{月份：6，可见：真}，
{月份：7，可见：真}，
{月份：8，可见：假}，
{月份：9，可见：真}，
{月份：10，可见：假}，
{月份：11，可见：假}，
{月份：12，可见：假}
];
设maxIndex=0；
常量findMaxIndex=arr=>{
设prev=0；
对于（让index=arr.length-1；index>=0；index--）{
prev=指数-1；
if（arr[index].visible==false&&arr[prev].visible！=false）
收益指数；
}
返回-1；
};
log（myArray.slice（0，findMaxIndex（myArray））您可以找到索引，直到您的索引被切片，然后只需获取此数组：

const findMaxIndex = arr => {
    let prev = 0;
    for (let index = arr.length - 1; index >= 0; index--) {
        prev = index - 1;
        if (arr[index].visible == false && arr[prev].visible !=  false)
          return index;
    }
    return -1;
};

console.log(myArray.slice(0, findMaxIndex(myArray)));

例如：


让myArray=[
{月份：1，可见：真}，
{月份：2，可见：false}，
{月份：3，可见：真}，
{月份：4，可见：false}，
{月份：5，可见：false}，
{月份：6，可见：真}，
{月份：7，可见：真}，
{月份：8，可见：假}，
{月份：9，可见：真}，
{月份：10，可见：假}，
{月份：11，可见：假}，
{月份：12，可见：假}
];
设maxIndex=0；
常量findMaxIndex=arr=>{
设prev=0；
对于（让index=arr.length-1；index>=0；index--）{
prev=指数-1；
if（arr[index].visible==false&&arr[prev].visible！=false）
收益指数；
}
返回-1；
};
log（myArray.slice（0，findMaxIndex（myArray））我确实有一个答案几乎就要准备好了，所以这对我来说有点欺骗；）你能写下你想要的输出吗？我确实有一个答案，几乎就要准备好了，所以这对我来说有点欺骗；）你能写下你想要的输出吗？通过向后迭代数组和在第一次匹配时
break
，找到
last
会更有效。谢谢你的回答，我能请你对第一部分和第二部分稍加评论吗？这对我来说是非常新的（你创建的过滤函数！）谢谢你的帮助@AJ989我添加了一些评论。如果还有一些你想解释的地方，请告诉我。我理解如果这些技术中有一些是新的，可能会有点混乱。它的核心是相当简单的javascript，并加入了一些令人困惑的类型脚本。通过向后迭代数组和在第一次匹配时打断数组，查找
最后一个
将更加有效。谢谢你的回答，我能请你对第一部分和第二部分稍加评论吗，这对我来说都是非常新的（你创建的过滤功能！）谢谢你的帮助！@AJ989我已经添加了一些注释。请告诉我你是否还有一些需要解释的地方。如果这些技术中有一些是新的，我很感激这可能会有点让人困惑。它的核心是相当简单的javascript，并加入了一些令人困惑的类型脚本。
const findMaxIndex = arr => {
    let prev = 0;
    for (let index = arr.length - 1; index >= 0; index--) {
        prev = index - 1;
        if (arr[index].visible == false && arr[prev].visible !=  false)
          return index;
    }
    return -1;
};

console.log(myArray.slice(0, findMaxIndex(myArray)));