在对象数组中查找最后一个匹配的对象

Question

我有一个对象数组。我需要获取最后一个对象的对象类型（本例中为“形状”），将其删除，然后在具有相同类型的数组中找到前一个对象的索引，例如“形状”。

var fruits = [
    { 
        shape: round,
        name: orange
    },
    { 
        shape: round,
        name: apple
    },
    { 
        shape: oblong,
        name: zucchini
    },
    { 
        shape: oblong,
        name: banana
    },
    { 
        shape: round,
        name: grapefruit
    }
]

// What's the shape of the last fruit
var currentShape =  fruits[fruits.length-1].shape;

// Remove last fruit
fruits.pop(); // grapefruit removed

// Find the index of the last round fruit
var previousInShapeType = fruits.lastIndexOf(currentShape);
    // should find apple, index = 1

所以，显然这个例子中的类型将是“圆形”。但我不是在寻找“round”的数组值。我正在寻找 fruits.shape = round 的位置。

var previousInShapeType = fruits.lastIndexOf(fruits.shape = currentShape);

但是仅仅使用它是行不通的。我确定我错过了一些简单的东西。如何在数组中找到对象形状 = 圆形的最后一项？

Answer 1

var fruit = fruits.slice().reverse().find(fruit => fruit.shape === currentShape);

Answer 2

您可以将数组转换为数组boolean 类型并获取最后一个true 索引。

const lastIndex = fruits.map(fruit => 
  fruit.shape === currentShape).lastIndexOf(true);

Answer 3

var previousInShapeType, index = fruits.length - 1;
for ( ; index >= 0; index--) {
    if (fruits[index].shape == currentShape) {
        previousInShapeType = fruits[index];
        break;
    }
}

你也可以通过数组向后循环。

小提琴：http://jsfiddle.net/vonn9xhm/

Answer 4

使用Lodash library，您可以找到最后一个逻辑元素。

_.findLast([1,2,3,5,4], n => n % 2 == 1); // Find last odd element
// expected output: 5

Answer 5

这是一个不依赖于reverse 的解决方案，因此不需要“克隆”原始集合。

const lastShapeIndex = fruits.reduce((acc, fruit, index) => (
    fruit.shape === currentShape ? index : acc
), -1);

Answer 6

一个更简单且相对有效的解决方案。 过滤并弹出！

过滤所有匹配当前形状的水果，然后pop得到最后一个。

fruits.filter(({shape}) => shape === currentShape).pop()

var fruits = [{
    shape: 'round',
    name: 'orange'
}, {
    shape: 'round',
    name: 'apple'
}, {
    shape: 'oblong',
    name: 'zucchini'
}, {
    shape: 'oblong',
    name: 'banana'
}, {
    shape: 'round',
    name: 'grapefruit'
}];

// What's the shape of the last fruit
var currentShape = fruits[fruits.length - 1].shape;

// Remove last fruit
fruits.pop(); // grapefruit removed


alert(fruits.filter(({shape}) => shape === currentShape).pop().name);

Answer 7

更新 - 2021 年 10 月 27 日（Chrome 97+）

Proposal for Array.prototype.findLast 和 Array.prototype.findLastIndex 现在处于第 3 阶段！

以下是您可以使用它们的方法：

const fruits = [
  { shape: 'round', name: 'orange' },
  { shape: 'round', name: 'apple' },
  { shape: 'oblong', name: 'zucchini' },
  { shape: 'oblong', name: 'banana' },
  { shape: 'round', name: 'grapefruit' }
]

let last_element = fruits.findLast((item) => item.shape === 'oblong');
// → { shape: oblong, name: banana }

let last_element_index = fruits.findLastIndex((item) => item.shape === 'oblong');
// → 3

您可以在this V8 blog post阅读更多内容。

您可以在"New in Chrome" series找到更多信息。

Answer 8

纯JS：

var len = fruits.length, prev = false;
while(!prev && len--){
    (fruits[len].shape == currentShape) && (prev = fruits[len]);
}

lodash：

_.findLast(fruits, 'shape', currentShape);

Answer 9

虽然当前接受的答案可以解决问题，但 ES6 (ECMA2015) 的到来添加了 spread 运算符，这使得复制您的数组变得容易（这对于您的示例中的 fruit 数组可以正常工作，但要注意嵌套数组）。您还可以利用 pop 方法返回已删除元素的事实来使您的代码更简洁。因此，您可以使用以下 2 行代码实现所需的结果

const currentShape = fruits.pop().shape;
const previousInShapeType = [...fruits].reverse().find(
  fruit => fruit.shape === currentShape
);

Answer 10

基于Luke Liu's answer，但使用ES6的spread operator使其更易于阅读：

const fruit = [...fruits].reverse().find(fruit => fruit.shape === currentShape);

Answer 11

更新 - Array.prototype.findLast() 现在可以使用了

var fruits = [
    { 
        shape: 'round',
        name: 'orange'
    },
    { 
        shape: 'round',
        name: 'apple'
    },
    { 
        shape: 'oblong',
        name: 'zucchini'
    },
    { 
        shape: 'oblong',
        name: 'banana'
    },
    { 
        shape: 'round',
        name: 'grapefruit'
    }
]


const last = fruits.findLast(n => n.shape === 'oblong');
console.log(last);

**在linklink使用前请检查浏览器是否兼容

阅读更多关于findLasthere

实现此目的的另一种方法是使用reverse（但效率较低）

var fruits = [
    { 
        shape: 'round',
        name: 'orange'
    },
    { 
        shape: 'round',
        name: 'apple'
    },
    { 
        shape: 'oblong',
        name: 'zucchini'
    },
    { 
        shape: 'oblong',
        name: 'banana'
    },
    { 
        shape: 'round',
        name: 'grapefruit'
    }
]


const last = fruits.reverse().find(n => n.shape === 'oblong');

console.log(last);

Answer 12

我会建议另一个不错的解决方案，它不需要使用reverse() 克隆新对象。

我使用reduceRight 来代替。

function findLastIndex(array, fn) {
  if (!array) return -1;
  if (!fn || typeof fn !== "function") throw `${fn} is not a function`;
  return array.reduceRight((prev, currentValue, currentIndex) => {
    if (prev > -1) return prev;
    if (fn(currentValue, currentIndex)) return currentIndex;
    return -1;
  }, -1);
}

及用法

findLastIndex([1,2,3,4,5,6,7,5,4,2,1], (current, index) => current === 2); // return 9

findLastIndex([{id: 1},{id: 2},{id: 1}], (current, index) => current.id === 1); //return 2

Answer 13

你应该使用过滤器！ filter 接受一个函数作为参数，并返回一个新数组。

var roundFruits = fruits.filter(function(d) {
 // d is each element of the original array
 return d.shape == "round";
});

现在 roundFruits 将包含函数返回 true 的原始数组的元素。现在，如果您想知道原始数组索引，请不要害怕 - 您可以使用函数映射。 map 还对数组进行操作，并采用作用于数组的函数。我们可以将 map 和 filter 链接在一起，如下所示

var roundFruits = fruits.map(function(d, i) {
  // d is each element, i is the index
  d.i = i;  // create index variable
  return d;
}).filter(function(d) {
  return d.shape == "round"
});

结果数组将包含原始 fruits 数组中形状为圆形的所有对象，以及它们在 fruits 数组中的原始索引。

roundFruits = [
{ 
    shape: round,
    name: orange,
    i: 0
},
{ 
    shape: round,
    name: apple,
    i: 1
},
{ 
    shape: round,
    name: grapefruit
    i: 4
}
]

现在，您可以在准确了解相关数据位置的情况下做任何您需要的事情。

// get last round element
fruits[4];

Answer 14

这是一个打字稿版本：

/**
 * Returns the value of the last element in the array where predicate is true, and undefined
 * otherwise. It's similar to the native find method, but searches in descending order.
 * @param list the array to search in.
 * @param predicate find calls predicate once for each element of the array, in descending
 * order, until it finds one where predicate returns true. If such an element is found, find
 * immediately returns that element value. Otherwise, find returns undefined.
 */
export function findLast<T>(
  list: Array<T>,
  predicate: (value: T, index: number, obj: T[]) => unknown
): T | undefined {
  for (let index = list.length - 1; index >= 0; index--) {
    let currentValue = list[index];
    let predicateResult = predicate(currentValue, index, list);
    if (predicateResult) {
      return currentValue;
    }
  }
  return undefined;
}

用法：

const r = findLast([12, 43, 5436, 44, 4], v => v < 45);
console.log(r); // 4