noAccumulatingSpread

このコンテンツはまだ日本語訳がありません。

JavaScript (and super languages)

Summary

Rule available since: v1.0.0
Diagnostic Category: lint/performance/noAccumulatingSpread
This rule is recommended, which means is enabled by default.
This rule doesn’t have a fix.
The default severity of this rule is warning.

How to configure

1
{
2
  "linter": {
3
    "rules": {
4
      "performance": {
5
        "noAccumulatingSpread": "error"
6
      }
7
    }
8
  }
9
}

Description

Disallow the use of spread (...) syntax on accumulators.

Spread syntax allows an iterable to be expanded into its individual elements.

Spread syntax should be avoided on accumulators (like those in .reduce) because it causes a time complexity of O(n^2) instead of O(n).

Source: https://prateeksurana.me/blog/why-using-object-spread-with-reduce-bad-idea/

Examples

Invalid

1
var a = ['a', 'b', 'c'];
2
a.reduce((acc, val) => [...acc, val], []);

code-block.js:2:25 lint/performance/noAccumulatingSpread ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ Avoid the use of spread (...) syntax on accumulators.
  
    1 │ var a = [‘a’, ‘b’, ‘c’];
  > 2 │ a.reduce((acc, val) => […acc, val], []);
      │                         ^^^^^^
    3 │ 
  
  ℹ Spread syntax should be avoided on accumulators (like those in .reduce) because it causes a time complexity of O(n^2).
  
  ℹ Consider methods such as .splice or .push instead.

1
var a = ['a', 'b', 'c'];
2
a.reduce((acc, val) => {return [...acc, val];}, []);

code-block.js:2:33 lint/performance/noAccumulatingSpread ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ Avoid the use of spread (...) syntax on accumulators.
  
    1 │ var a = [‘a’, ‘b’, ‘c’];
  > 2 │ a.reduce((acc, val) => {return […acc, val];}, []);
      │                                 ^^^^^^
    3 │ 
  
  ℹ Spread syntax should be avoided on accumulators (like those in .reduce) because it causes a time complexity of O(n^2).
  
  ℹ Consider methods such as .splice or .push instead.

1
var a = ['a', 'b', 'c'];
2
a.reduce((acc, val) => ({...acc, [val]: val}), {});

code-block.js:2:26 lint/performance/noAccumulatingSpread ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ Avoid the use of spread (...) syntax on accumulators.
  
    1 │ var a = [‘a’, ‘b’, ‘c’];
  > 2 │ a.reduce((acc, val) => ({…acc, [val]: val}), {});
      │                          ^^^^^^
    3 │ 
  
  ℹ Spread syntax should be avoided on accumulators (like those in .reduce) because it causes a time complexity of O(n^2).
  
  ℹ Consider methods such as .splice or .push instead.

1
var a = ['a', 'b', 'c'];
2
a.reduce((acc, val) => Object.assign(acc, val), []);

code-block.js:2:24 lint/performance/noAccumulatingSpread ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ Avoid the use of Object.assign on accumulators.
  
    1 │ var a = [‘a’, ‘b’, ‘c’];
  > 2 │ a.reduce((acc, val) => Object.assign(acc, val), []);
      │                        ^^^^^^^^^^^^^
    3 │ 
  
  ℹ Spread syntax should be avoided on accumulators (like those in .reduce) because it causes a time complexity of O(n^2).
  
  ℹ Consider methods such as .splice or .push instead.

1
var a = ['a', 'b', 'c'];
2
a.reduce((acc, val) => {return Object.assign(acc, val);}, []);

code-block.js:2:32 lint/performance/noAccumulatingSpread ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ Avoid the use of Object.assign on accumulators.
  
    1 │ var a = [‘a’, ‘b’, ‘c’];
  > 2 │ a.reduce((acc, val) => {return Object.assign(acc, val);}, []);
      │                                ^^^^^^^^^^^^^
    3 │ 
  
  ℹ Spread syntax should be avoided on accumulators (like those in .reduce) because it causes a time complexity of O(n^2).
  
  ℹ Consider methods such as .splice or .push instead.

Valid

1
var a = ['a', 'b', 'c'];
2
a.reduce((acc, val) => {acc.push(val); return acc}, []);