arrow-body-style

Require braces around arrow function bodies

Arrow functions have two syntactic forms for their function bodies. They may be defined with a block body (denoted by curly braces) () => { ... } or with a single expression () => ..., whose value is implicitly returned.

Rule Details

This rule can enforce or disallow the use of braces around arrow function body.

Options

The rule takes one or two options. The first is a string, which can be:

• "always" enforces braces around the function body
• "as-needed" enforces no braces where they can be omitted (default)
• "never" enforces no braces around the function body (constrains arrow functions to the role of returning an expression)

The second one is an object for more fine-grained configuration when the first option is "as-needed". Currently, the only available option is requireReturnForObjectLiteral, a boolean property. It’s false by default. If set to true, it requires braces and an explicit return for object literals.

"arrow-body-style": ["error", "always"]
1

always

Examples of incorrect code for this rule with the "always" option:

/*eslint arrow-body-style: ["error", "always"]*/

let foo = () => 0;
1
2
3

Examples of correct code for this rule with the "always" option:

/*eslint arrow-body-style: ["error", "always"]*/

let foo = () => {
    return 0;
};
let bar = (retv, name) => {
    retv[name] = true;
    return retv;
};
1
2
3
4
5
6
7
8
9

as-needed

Examples of incorrect code for this rule with the default "as-needed" option:

/*eslint arrow-body-style: ["error", "as-needed"]*/

let foo = () => {
    return 0;
};
let bar = () => {
    return {
       bar: {
            foo: 1,
            bar: 2,
        }
    };
};
1
2
3
4
5
6
7
8
9
10
11
12
13

Examples of correct code for this rule with the default "as-needed" option:

/*eslint arrow-body-style: ["error", "as-needed"]*/

let foo1 = () => 0;
let foo2 = (retv, name) => {
    retv[name] = true;
    return retv;
};
let foo3 = () => ({
    bar: {
        foo: 1,
        bar: 2,
    }
});
let foo4 = () => { bar(); };
let foo5 = () => {};
let foo6 = () => { /* do nothing */ };
let foo7 = () => {
    // do nothing.
};
let foo8 = () => ({ bar: 0 });
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

requireReturnForObjectLiteral

This option is only applicable when used in conjunction with the "as-needed" option.

Examples of incorrect code for this rule with the { "requireReturnForObjectLiteral": true } option:

/*eslint arrow-body-style: ["error", "as-needed", { "requireReturnForObjectLiteral": true }]*/

let foo = () => ({});
let bar = () => ({ bar: 0 });
1
2
3
4

Examples of correct code for this rule with the { "requireReturnForObjectLiteral": true } option:

/*eslint arrow-body-style: ["error", "as-needed", { "requireReturnForObjectLiteral": true }]*/

let foo = () => {};
let bar = () => { return { bar: 0 }; };
1
2
3
4

never

Examples of incorrect code for this rule with the "never" option:

/*eslint arrow-body-style: ["error", "never"]*/

let foo = () => {
    return 0;
};
let bar = (retv, name) => {
    retv[name] = true;
    return retv;
};
1
2
3
4
5
6
7
8
9

Examples of correct code for this rule with the "never" option:

/*eslint arrow-body-style: ["error", "never"]*/

let foo = () => 0;
let bar = () => ({ foo: 0 });
1
2
3
4

Version

This rule was introduced in ESLint v1.8.0.

Resources

• Rule source
• Tests source