This rule raises an issue when legacy array flattening techniques are used instead of the native Array#flat() method introduced in ES2019.

Why is this an issue?

ES2019 introduced the Array#flat() method as the standard way to flatten arrays. This method is more readable and expressive than legacy techniques.

Before Array#flat(), developers used various workarounds to flatten arrays:

• Using flatMap() with an identity function
• Using reduce() with concat() or spread operators
• Using concat() with apply() or spread syntax
• Using utility library functions like _.flatten()

These legacy approaches have several drawbacks:

• Less readable: The intent to flatten an array is not immediately clear
• More verbose: They require more code to achieve the same result
• Inconsistent: Different patterns are used across codebases
• Performance: Some patterns may be less efficient than the native method

The native Array#flat() method clearly expresses the intent to flatten an array and is the modern standard approach.

What is the potential impact?

Using legacy flattening techniques makes code harder to read and maintain. The intent to flatten an array is not immediately obvious, which can slow down code reviews and debugging. Additionally, some legacy patterns may have performance implications compared to the optimized native method.

How to fix?

Replace flatMap() with identity function with flat().

Non-compliant code example

const flattened = array.flatMap(x => x); // Noncompliant

Compliant code example

const flattened = array.flat();

Documentation

• eslint-plugin-unicorn - Rule prefer-array-flat
• MDN - Array.prototype.flat() - Official documentation for the Array.flat() method
• ESLint Unicorn - prefer-array-flat - Original ESLint rule documentation

Standards

• ECMAScript 2019 (ES10) - ECMAScript specification for Array.prototype.flat

Related Rules

• RSPEC-XXXX - Prefer Array.flatMap() over legacy techniques