max-depth

Enforce a maximum depth that blocks can be nested

Many developers consider code difficult to read if blocks are nested beyond a certain depth.

Rule Details

This rule enforces a maximum depth that blocks can be nested to reduce code complexity.

Options

This rule has a number or object option:

• "max" (default 4) enforces a maximum depth that blocks can be nested

Deprecated: The object property maximum is deprecated; please use the object property max instead.

max

Examples of incorrect code for this rule with the default { "max": 4 } option:

/*eslint max-depth: ["error", 4]*/

function foo() {
    for (;;) { // Nested 1 deep
        while (true) { // Nested 2 deep
            if (true) { // Nested 3 deep
                if (true) { // Nested 4 deep
                    if (true) { // Nested 5 deep
                    }
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Examples of correct code for this rule with the default { "max": 4 } option:

/*eslint max-depth: ["error", 4]*/

function foo() {
    for (;;) { // Nested 1 deep
        while (true) { // Nested 2 deep
            if (true) { // Nested 3 deep
                if (true) { // Nested 4 deep
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

Note that class static blocks do not count as nested blocks, and that the depth in them is calculated separately from the enclosing context.

Examples of incorrect code for this rule with { "max": 2 } option:

/*eslint max-depth: ["error", 2]*/

function foo() {
    if (true) { // Nested 1 deep
        class C {
            static {
                if (true) { // Nested 1 deep
                    if (true) { // Nested 2 deep
                        if (true) { // Nested 3 deep
                        }
                    }
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Examples of correct code for this rule with { "max": 2 } option:

/*eslint max-depth: ["error", 2]*/

function foo() {
    if (true) { // Nested 1 deep
        class C {
            static {
                if (true) { // Nested 1 deep
                    if (true) { // Nested 2 deep
                    }
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Related Rules

• complexity
• max-len
• max-lines
• max-lines-per-function
• max-nested-callbacks
• max-params
• max-statements

Version

This rule was introduced in ESLint v0.0.9.

Resources

• Rule source
• Tests source