New rule: disallow push in Array.forEach

Please describe what the rule should do:

The rule should disallow pushing results from Array.prototype.forEach to another array. Instead, Array.prototype.map should be used.

What category of rule is this? (place an “X” next to just one item)

[ ] Enforces code style [ ] Warns about a potential error [x] Suggests an alternate way of doing something [ ] Other (please specify:)

Provide 2-3 code examples that this rule will warn about:

// Disallowed
const result = [];
input.forEach(item => {
  result.push(item + 1);
});

// Alternative construct
const result = input.map(item => item +1);

// Disallowed
const result = [];
input.forEach(item => {
  if (item > 10) {
    result.push(item + 1);
  }
});

// Alternative construct
const result = input
  .filter(item => item > 10)
  .map(item => item +1);

Why should this rule be included in ESLint (instead of a plugin)?

• It is generic to a core part of JavaScript.
• I’ve manually detected the disallowed pattern many times in code review. Many people don’t seem to consider the alternative.
• It doesn’t fit in any existing plugin I’m aware of.

[not-an-aardvark]

So just to clarify, would this rule disallow any call to a .push() function from inside a .forEach() function? There are a few other cases where it can’t be directly translated to a map/filter:

foo.forEach(element => {
  doSomethingWithSideEffects();
  bar.push(element);
});

I’m not sure how I feel about the rule yet; I agree that using something like .map() is generally better than .forEach() and .push(), but I’m concerned that we won’t be able to detect this accurately enough.

[Wilfred]

FWIW, array-callback-return has exactly the same limitation.