complexity

Enforce a maximum cyclomatic complexity allowed in a program

循环复杂度衡量的是通过程序源代码的线性独立路径的数量。这条规则允许设置一个循环复杂度阈值。

function a(x) {
    if (true) {
        return x; // 1st path
    } else if (false) {
        return x+1; // 2nd path
    } else {
        return 4; // 3rd path
    }
}
1
2
3
4
5
6
7
8
9

规则细节

这条规则旨在通过限制程序中允许的循环复杂性来减少代码的复杂性。因此，当循环复杂度超过配置的阈值（默认为 20）时，它将发出警告。

最大值为 2 的错误示例：

Open in Playground

/*eslint complexity: ["error", 2]*/

function a(x) {
    if (true) {
        return x;
    } else if (false) {
        return x+1;
    } else {
        return 4; // 3rd path
    }
}

function b() {
    foo ||= 1;
    bar &&= 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

最大值为 2 的正确示例：

Open in Playground

/*eslint complexity: ["error", 2]*/

function a(x) {
    if (true) {
        return x;
    } else {
        return 4;
    }
}

function b() {
    foo ||= 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

类的字段初始化器和类的静态块是隐式函数。因此，它们的复杂性是针对每个初始化器和每个静态块单独计算的，而且它不对包围代码的复杂性做出贡献。

最大值为 2 的额外错误示例：

Open in Playground

/*eslint complexity: ["error", 2]*/

class C {
    x = a || b || c; // this initializer has complexity = 3
}

class D { // this static block has complexity = 3
    static {
        if (foo) {
            bar = baz || qux;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

最大值为 2 的额外正确示例：

Open in Playground

/*eslint complexity: ["error", 2]*/

function foo() { // this function has complexity = 1
    class C {
        x = a + b; // this initializer has complexity = 1
        y = c || d; // this initializer has complexity = 2
        z = e && f; // this initializer has complexity = 2

        static p = g || h; // this initializer has complexity = 2
        static q = i ? j : k; // this initializer has complexity = 2

        static { // this static block has complexity = 2
            if (foo) {
                baz = bar;
            }
        }

        static { // this static block has complexity = 2
            qux = baz || quux;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22