array-callback-return

在数组方法的回调中强制执行 return 语句

Array 有几种过滤、映射和折叠的方法。如果我们忘记在这些回调中写 return 语句，那可能是一个错误。如果你不想使用 return 或不需要返回的结果，请考虑使用 .forEach 代替。

¥Array has several methods for filtering, mapping, and folding. If we forget to write return statement in a callback of those, it’s probably a mistake. If you don’t want to use a return or don’t need the returned results, consider using .forEach instead.

// example: convert ['a', 'b', 'c'] --> {a: 0, b: 1, c: 2}
const indexMap = myArray.reduce(function(memo, item, index) {
  memo[item] = index;
}, {}); // Error: cannot set property 'b' of undefined
1
2
3
4

规则详情

¥Rule Details

此规则强制在数组方法的回调中使用 return 语句。此外，它还可以使用 checkForEach 选项强制 forEach 数组方法回调不返回值。

¥This rule enforces usage of return statement in callbacks of array’s methods. Additionally, it may also enforce the forEach array method callback to not return a value by using the checkForEach option.

此规则查找以下方法的回调函数，然后检查 return 语句的使用情况。

¥This rule finds callback functions of the following methods, then checks usage of return statement.

• Array.from

• Array.prototype.every

• Array.prototype.filter

• Array.prototype.find

• Array.prototype.findIndex

• Array.prototype.findLast

• Array.prototype.findLastIndex

• Array.prototype.flatMap

• Array.prototype.forEach（可选，基于 参数）

  ¥Array.prototype.forEach (optional, based on checkForEach parameter)

• Array.prototype.map

• Array.prototype.reduce

• Array.prototype.reduceRight

• Array.prototype.some

• Array.prototype.sort

• Array.prototype.toSorted

• 及以上类型的数组。

  ¥And above of typed arrays.

此规则的错误代码示例：

¥Examples of incorrect code for this rule:

/*eslint array-callback-return: "error"*/

const indexMap = myArray.reduce(function(memo, item, index) {
    memo[item] = index;
}, {});

const foo = Array.from(nodes, function(node) {
    if (node.tagName === "DIV") {
        return true;
    }
});

const bar = foo.filter(function(x) {
    if (x) {
        return true;
    } else {
        return;
    }
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

此规则的正确代码示例：

¥Examples of correct code for this rule:

/*eslint array-callback-return: "error"*/

const indexMap = myArray.reduce(function(memo, item, index) {
    memo[item] = index;
    return memo;
}, {});

const foo = Array.from(nodes, function(node) {
    if (node.tagName === "DIV") {
        return true;
    }
    return false;
});

const bar = foo.map(node => node.getAttribute("id"));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

选项

¥Options

该规则接受具有三个选项的配置对象：

¥This rule accepts a configuration object with three options:

• "allowImplicit": false（默认）当设置为 true 时，允许需要返回值的方法的回调隐式返回 undefined，其中 return 语句不包含表达式。

  ¥"allowImplicit": false (default) When set to true, allows callbacks of methods that require a return value to implicitly return undefined with a return statement containing no expression.

• "checkForEach": false（默认）当设置为 true 时，规则还将报告返回值的 forEach 回调。

  ¥"checkForEach": false (default) When set to true, rule will also report forEach callbacks that return a value.

• "allowVoid": false（默认）当设置为 true 时，允许 forEach 回调中使用 void，因此规则不会使用 void 运算符报告返回值。

  ¥"allowVoid": false (default) When set to true, allows void in forEach callbacks, so rule will not report the return value with a void operator.

注意：仅当 checkForEach 选项设置为 true 时，{ "allowVoid": true } 才起作用。

¥Note: { "allowVoid": true } works only if checkForEach option is set to true.

allowImplicit

{ "allowImplicit": true } 选项的正确代码示例：

¥Examples of correct code for the { "allowImplicit": true } option:

/*eslint array-callback-return: ["error", { allowImplicit: true }]*/
const undefAllTheThings = myArray.map(function(item) {
    return;
});
1
2
3
4

checkForEach

{ "checkForEach": true } 选项的错误代码示例：

¥Examples of incorrect code for the { "checkForEach": true } option:

/*eslint array-callback-return: ["error", { checkForEach: true }]*/

myArray.forEach(function(item) {
    return handleItem(item);
});

myArray.forEach(function(item) {
    if (item < 0) {
        return x;
    }
    handleItem(item);
});

myArray.forEach(function(item) {
    if (item < 0) {
        return void x;
    }
    handleItem(item);
});

myArray.forEach(item => handleItem(item));

myArray.forEach(item => void handleItem(item));

myArray.forEach(item => {
    return handleItem(item);
});

myArray.forEach(item => {
    return void handleItem(item);
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

{ "checkForEach": true } 选项的正确代码示例：

¥Examples of correct code for the { "checkForEach": true } option:

/*eslint array-callback-return: ["error", { checkForEach: true }]*/

myArray.forEach(function(item) {
    handleItem(item)
});

myArray.forEach(function(item) {
    if (item < 0) {
        return;
    }
    handleItem(item);
});

myArray.forEach(function(item) {
    handleItem(item);
    return;
});

myArray.forEach(item => {
    handleItem(item);
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

allowVoid

{ "allowVoid": true } 选项的正确代码示例：

¥Examples of correct code for the { "allowVoid": true } option:

/*eslint array-callback-return: ["error", { checkForEach: true, allowVoid: true }]*/

myArray.forEach(item => void handleItem(item));

myArray.forEach(item => {
    return void handleItem(item);
});

myArray.forEach(item => {
    if (item < 0) {
        return void x;
    }
    handleItem(item);
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14

已知限制

¥Known Limitations

此规则检查具有给定名称的方法的回调函数，即使具有该方法的对象不是数组。

¥This rule checks callback functions of methods with the given names, even if the object which has the method is not an array.

何时不使用

¥When Not To Use It

如果你不想在数组方法的回调中警告使用 return 语句，那么禁用此规则是安全的。

¥If you don’t want to warn about usage of return statement in callbacks of array’s methods, then it’s safe to disable this rule.

版本

此规则是在 ESLint v2.0.0-alpha-1 中引入。

资源

• 规则源码
• 测试源码