版本

复杂度

强制执行程序中允许的最大环路复杂度

环路复杂度衡量程序源代码中线性无关路径的数量。此规则允许设置环路复杂度阈值。

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 的错误代码示例

在游乐场中打开

/*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;
}

function c(a = {}) { // default parameter -> 2nd path
    const { b = 'default' } = a; // default value during destructuring -> 3rd path
}

function d(a) {
    return a?.b?.c; // optional chaining with two optional properties creates two additional branches
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

最大值为 2 的正确代码示例

在游乐场中打开

/*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 的其他错误代码示例

在游乐场中打开

/*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 的其他正确代码示例

在游乐场中打开

/*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

选项

此规则具有数字或对象选项

"max"（默认值：20）强制执行最大复杂度
"variant": "classic" | "modified"（默认值："classic"）要使用的环路复杂度变体

max

使用 max 属性自定义阈值。

"complexity": ["error", { "max": 2 }]
1

已弃用：对象属性 maximum 已弃用。请改用属性 max。

或使用简写语法

"complexity": ["error", 2]
1

variant

要使用的环路复杂度变体

"classic"（默认值） - 经典的 McCabe 环路复杂度
"modified" - 修改后的环路复杂度

修改后的环路复杂度与经典的环路复杂度相同，但每个 switch 语句仅将复杂度值增加 1，而不管它包含多少个 case 语句。

使用 { "max": 3, "variant": "modified" } 选项时，此规则的正确代码示例

在游乐场中打开

/*eslint complexity: ["error", {"max": 3, "variant": "modified"}]*/

function a(x) {     // initial modified complexity is 1
    switch (x) {    // switch statement increases modified complexity by 1
        case 1:
            1;
            break;
        case 2:
            2;
            break;
        case 3:
            if (x === 'foo') {  // if block increases modified complexity by 1
                3;
            }
            break;
        default:
            4;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

上面函数的经典环路复杂度为 5，但修改后的环路复杂度仅为 3。

何时不使用它

如果您无法确定代码的适当复杂度限制，最好禁用此规则。

版本

此规则是在 ESLint v0.0.9 中引入的。

进一步阅读

环路复杂度 - 维基百科
en.wikipedia.org

JavaScript 代码的复杂度分析
ariya.io

JavaScript 的复杂度
craftsmanshipforsoftware.com

关于复杂度 | JSComplexity.org
web.archive.org

复杂度没有默认值 · Issue #4808 · eslint/eslint
github.com

资源

编辑此页面