直接使用.reduce可能很难阅读，所以我建议创建一个生成reducer的函数:

function mapfilter(mapper) {
  return (acc, val) => {
    const mapped = mapper(val);
    if (mapped !== false)
      acc.push(mapped);
    return acc;
  };
}

像这样使用它:

const words = "Map and filter an array #javascript #arrays";
const tags = words.split(' ')
  .reduce(mapfilter(word => word.startsWith('#') && word.slice(1)), []);
console.log(tags);  // ['javascript', 'arrays'];

嘿，我刚刚在这个项目上工作，想在MDN文档中分享我基于Array.prototype.flatMap()的解决方案:

const places=[{latitude:40,longitude:1},{latitude:41,longitude:2},{latitude:44,longitude:2},{latitude:NaN,longitude:NaN},{latitude:45,longitude:4},{latitude:48,longitude:3},{latitude:44,longitude:5},{latitude:39,longitude:13},{latitude:40,longitude:8},{latitude:38,longitude:4}]; let items = places?.map((place) => [{ latitude: (place.latitude), longitude: (place.longitude), }, ]); console.log("Items: ", items); //Remove elements with NaN latitude and longitude let newItems = places?.flatMap((o) => Number(o.longitude, o.latitude) ? { lng: Number(o.longitude), lat: Number(o.latitude) } : [] ); console.log("Coordinates after NaN values removed: ", newItems);

从2019年开始，Array.prototype.flatMap是一个不错的选择。

options.flatMap(o => o.assigned ? [o.name] : []);

从MDN页面上方链接:

flatMap可以作为一种添加和删除项目的方法(修改 项目数目)在一个地图。换句话说，它允许您进行映射 多项对多项(通过分别处理每个输入项)， 而不是总是一对一。在这个意义上，它就像 filter的反义词。只需返回一个1元素的数组来保存该项， 用于添加项的多元素数组，或用于删除项的0元素数组 的项目。

使用Array.prototype.filter:

function renderOptions(options) {
    return options.filter(function(option){
        return !option.assigned;
    }).map(function (option) {
        return (someNewObject);
    });   
}

同时执行filter + map的最有效方法是将数据作为泛型可迭代对象处理，并同时执行这两件事。在这种情况下，您最多只需要浏览一次数据。

下面的例子是使用iter-ops库，并做到了这一点:

import {pipe, filter, map} from 'iter-ops';

const i = pipe(
    inputArray,
    filter(value => value === 123), // filter on whatever key you want
    map(value => /* any mapping here*/) // remap data as you like
);

// i = iterable that can be processed further;

console.log([...i]); //=> list of new objects

上面，我说的是最多，因为如果你对iterable结果应用进一步的逻辑，比如限制映射项的数量，例如，你最终会迭代对象列表甚至少于一次:

const i = pipe(
    inputArray,
    filter(value => value === 123), // filter on whatever key you want
    map(value => /* any mapping here*/), // remap as you like
    take(10) // take up to 10 items only
);

在上面，我们进一步限制迭代，一旦生成了10个结果项就停止，因此我们对数据的迭代少于一次。这是最有效的了。

更新

我被要求补充为什么这种解决方案比减少更有效，所以就是这样……

数组的约简是一个有限的操作，它遍历完整的数据集，以产生结果。因此，当您需要对输出数据进行进一步处理时，您将最终生成一个新的迭代序列，等等。

当您有一个复杂的业务逻辑要应用到一个序列/可迭代对象时，将该逻辑链接起来总是更有效的，而只遍历序列一次。在许多情况下，您最终会对一个序列进行复杂的处理，甚至一次都不遍历完整的数据集。这就是可迭代数据处理的效率。

附注:我是上述图书馆的作者。

这里有一行使用ES6花哨扩展语法的简化!

Var选项= [ {name: 'One'， assigned: true}， {name: 'Two'，赋值:false}， {name: 'Three'，赋值:true}， ]; Const filtered = options .reduce((result， {name, assigned}) =>[…]结果,…分配?[name]: []]， []); console.log(过滤);