如果数组中的元素与JavaScript中的前一个元素具有相同的属性，是否有方法跳过该元素？

正如我在标题中提到的，我有一个JavaScript对象列表，其结构如下：

[
    {value: 1, date: timestamp},
    {value: 1, date: timestamp + 1},
    {value: 0, date: timestamp + 2}
]

有没有办法跳过与上一个值相同的每个对象？值只能为1或0。 我在考虑一些过滤器或减少/比较的组合

结果如下：

[
    {value: 1, date: timestamp},
    {value: 0, date: timestamp + 2}
]

---

请尝试以下方法

const newObjects = objects.reduce((cur, obj) => {
  if (!cur.length || obj.value !== cur[cur.length - 1].length) {
     cur.push(obj);
  }
  return cur;
}, []);

---

请尝试以下方法

const newObjects = objects.reduce((cur, obj) => {
  if (!cur.length || obj.value !== cur[cur.length - 1].length) {
     cur.push(obj);
  }
  return cur;
}, []);

---

在进行迭代时，只需记住上一项的值。如果匹配，你就继续。比如说：

skipEveryOther(input_arr){
    let prevVal=null;
    const toReturn=[]
    for(let i=0; i<input_arr.length; i+=1){
        const curObj=input_arr[i];
        if(curObj.value!=prevVal){
           toReturn.push(curObj);
           prevVal=curObj.value;
        }
    }
    return toReturn;
}

skipEveryOther（输入）{
设prevVal=null；
常数toReturn=[]
对于（让i=0；i迭代时，您只需记住上一项的值。如果它匹配，您只需继续。类似于这样：

skipEveryOther(input_arr){
    let prevVal=null;
    const toReturn=[]
    for(let i=0; i<input_arr.length; i+=1){
        const curObj=input_arr[i];
        if(curObj.value!=prevVal){
           toReturn.push(curObj);
           prevVal=curObj.value;
        }
    }
    return toReturn;
}

skipEveryOther（输入）{
设prevVal=null；
常数toReturn=[]
对于（设i=0；i，使用过滤器并记住最后一个值


let timestamp=0；
设arr=[
{值：1，日期：时间戳}，
{值：1，日期：时间戳+1}，
{值：0，日期：时间戳+2}，
{值：1，日期：timestamp+32}，
{值：1，日期：时间戳+4}
];
设last=null；
let result=arr.filter（obj=>{
如果（对象值===最后一个）{
返回错误
}否则{
last=目标值；
返回true；
}
});
console.log（结果）；
使用过滤器并记住最后一个值


let timestamp=0；
设arr=[
{值：1，日期：时间戳}，
{值：1，日期：时间戳+1}，
{值：0，日期：时间戳+2}，
{值：1，日期：timestamp+32}，
{值：1，日期：时间戳+4}
];
设last=null；
let result=arr.filter（obj=>{
如果（对象值===最后一个）{
返回错误
}否则{
last=目标值；
返回true；
}
});
console.log（result）；
使用reduce执行此操作的方法确实不可读


var数据=[
{值：1，日期：0}，
{值：1，日期：1}，
{值：0，日期：2}
]
康斯特=
数据.减少（
（obj，记录）=>(
！obj.s[记录值]&&
（obj.s[记录值]=1）和
obj.a.push（记录），
（obj）
，{s:{}，a:[]}）；
console.log（已清理）
使用reduce执行此操作的方法确实不可读


var数据=[
{值：1，日期：0}，
{值：1，日期：1}，
{值：0，日期：2}
]
康斯特=
数据.减少（
（obj，记录）=>(
！obj.s[记录值]&&
（obj.s[记录值]=1）和
obj.a.push（记录），
（obj）
，{s:{}，a:[]}）；
console.log（已清理）
一个简单的
.map（）
可能会起到以下作用：

const arr = [{
    value: 1,
    date: timestamp
  },
  {
    value: 1,
    date: timestamp + 1
  },
  {
    value: 0,
    date: timestamp + 2
  }
];

arr.map((n, index) => {
  if (
    !arr[index - 1] || // if there is NOT an element behind us
    n.value !== arr[index - 1].value // compare the current element to the one before it
  ) {
    console.log(n)
  }
})


一个简单的
.map（）
就可以做到：

const arr = [{
    value: 1,
    date: timestamp
  },
  {
    value: 1,
    date: timestamp + 1
  },
  {
    value: 0,
    date: timestamp + 2
  }
];

arr.map((n, index) => {
  if (
    !arr[index - 1] || // if there is NOT an element behind us
    n.value !== arr[index - 1].value // compare the current element to the one before it
  ) {
    console.log(n)
  }
})


只需使用最后一个值进行筛选


const
时间戳=“”，
数据=[{value:1，日期：时间戳}，{value:1，日期：时间戳+1}，{value:0，日期：时间戳+2}]，
result=data.filter（{value}，i，{[i-1]：{value:last}={}}）=>value！==last）；
log（结果）；
只需使用最后一个值进行筛选


const
时间戳=“”，
数据=[{value:1，日期：时间戳}，{value:1，日期：时间戳+1}，{value:0，日期：时间戳+2}]，
result=data.filter（{value}，i，{[i-1]：{value:last}={}}）=>value！==last）；
console.log（result）；
“有办法吗？”是的。我建议编写一个循环。谢谢。我知道如何通过简单的循环来实现它，但是我正在考虑更单线的方法。我给了你答案……”有办法吗？“是的。我建议写一个循环。谢谢。我知道如何通过简单的循环来实现它，但是我在考虑更单线的东西。我给了你答案…你的reduce看起来是backwards@epascarello“向后”是什么意思？请详细说明。reduce是
（累加器，当前值）
您有
（当前值，累加器）
或者我正在读你做错了什么。你在@epascarello上绝对正确。我太自信了。我现在已经更新了。你的reduce似乎是backwards@epascarello“向后”是什么意思？请详细说明。reduce是
（累加器，当前值）
您有
（当前值，累加器）
或者我正在读你做错了什么。你在@epascarello上完全正确。我太自信了。我现在已经更新了它