no-unsafe-finally

禁止 finally 块中的控制流语句

✅

在配置文件中使用来自 @eslint/js 的 recommended 配置可以启用此规则

JavaScript 暂停 try 和 catch 块的控制流语句，直到 finally 块的执行完成。因此，当在 finally 中使用 return、throw、break 或 continue 时，try 和 catch 内部的控制流语句被覆盖，这被认为是意外行为。如：

¥JavaScript suspends the control flow statements of try and catch blocks until the execution of finally block finishes. So, when return, throw, break, or continue is used in finally, control flow statements inside try and catch are overwritten, which is considered as unexpected behavior. Such as:

// We expect this function to return 1;
(() => {
    try {
        return 1; // 1 is returned but suspended until finally block ends
    } catch(err) {
        return 2;
    } finally {
        return 3; // 3 is returned before 1, which we did not expect
    }
})();

// > 3
1
2
3
4
5
6
7
8
9
10
11
12

// We expect this function to throw an error, then return
(() => {
    try {
        throw new Error("Try"); // error is thrown but suspended until finally block ends
    } finally {
        return 3; // 3 is returned before the error is thrown, which we did not expect
    }
})();

// > 3
1
2
3
4
5
6
7
8
9
10

// We expect this function to throw Try(...) error from the catch block
(() => {
    try {
        throw new Error("Try")
    } catch(err) {
        throw err; // The error thrown from try block is caught and rethrown
    } finally {
        throw new Error("Finally"); // Finally(...) is thrown, which we did not expect
    }
})();

// > Uncaught Error: Finally(...)
1
2
3
4
5
6
7
8
9
10
11
12

// We expect this function to return 0 from try block.
(() => {
  label: try {
    return 0; // 0 is returned but suspended until finally block ends
  } finally {
    break label; // It breaks out the try-finally block, before 0 is returned.
  }
  return 1;
})();

// > 1
1
2
3
4
5
6
7
8
9
10
11

规则详情

¥Rule Details

此规则不允许 finally 块内的 return、throw、break 和 continue 语句。它允许间接使用，例如在 function 或 class 定义中。

¥This rule disallows return, throw, break, and continue statements inside finally blocks. It allows indirect usages, such as in function or class definitions.

此规则的错误代码示例：

¥Examples of incorrect code for this rule:

在线运行

/*eslint no-unsafe-finally: "error"*/
let foo = function() {
    try {
        return 1;
    } catch(err) {
        return 2;
    } finally {
        return 3;
    }
};
1
2
3
4
5
6
7
8
9
10

在线运行

/*eslint no-unsafe-finally: "error"*/
let foo = function() {
    try {
        return 1;
    } catch(err) {
        return 2;
    } finally {
        throw new Error;
    }
};
1
2
3
4
5
6
7
8
9
10

此规则的正确代码示例：

¥Examples of correct code for this rule:

在线运行

/*eslint no-unsafe-finally: "error"*/
let foo = function() {
    try {
        return 1;
    } catch(err) {
        return 2;
    } finally {
        console.log("hola!");
    }
};
1
2
3
4
5
6
7
8
9
10

在线运行

/*eslint no-unsafe-finally: "error"*/
let foo = function() {
    try {
        return 1;
    } catch(err) {
        return 2;
    } finally {
        let a = function() {
            return "hola!";
        }
    }
};
1
2
3
4
5
6
7
8
9
10
11
12

在线运行

/*eslint no-unsafe-finally: "error"*/
let foo = function(a) {
    try {
        return 1;
    } catch(err) {
        return 2;
    } finally {
        switch(a) {
            case 1: {
                console.log("hola!")
                break;
            }
        }
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

何时不使用

¥When Not To Use It

如果要允许 finally 块中的控制流操作，可以关闭此规则。

¥If you want to allow control flow operations in finally blocks, you can turn this rule off.

版本

此规则是在 ESLint v2.9.0 中引入。

no-unsafe-finally

规则详情

何时不使用

版本

资源