标签: try-finally

看看以下两种方法:

public static void foo() {
    try {
        foo();
    } finally {
        foo();
    }
}

public static void bar() {
    bar();
}

运行bar()清楚导致a StackOverflowError,但运行foo()没有(程序似乎只是无限期运行).这是为什么？

我不知道为什么我们需要finally在try...except...finally声明中.在我看来,这个代码块

try:
    run_code1()
except TypeError:
    run_code2()
other_code()

与使用finally以下内容相同:

try:
    run_code1()
except TypeError:
    run_code2()
finally:
    other_code()

我错过了什么吗？

我有一个简单的Java类,如下所示:

public class Test {

    private String s;

    public String foo() {
        try {
            s = "dev";
            return s;
        } 
        finally {
            s = "override variable s";
            System.out.println("Entry in finally Block");  
        }
    }

    public static void main(String[] xyz) {
        Test obj = new Test();
        System.out.println(obj.foo());
    }
}

这段代码的输出是这样的:

Entry in finally Block
dev  

为什么s不在finally块中覆盖,而是控制打印输出？

我正在审查一些新代码.该程序只有一个try和一个finally块.由于catch块被排除在外,如果遇到异常或任何可抛出的东西,try块如何工作？它只是直接进入finally块吗？

有什么区别

try {
    fooBar();
} finally {
    barFoo();
}

和

try {
  fooBar();
} catch(Throwable throwable) {
    barFoo(throwable); // Does something with throwable, logs it, or handles it.
}

我更喜欢第二个版本,因为它让我可以访问Throwable.两种变体之间是否有任何逻辑差异或首选约定？

另外,有没有办法从finally子句访问异常？

try/catch块中的return语句如何工作？

function example() {
    try {
        return true;
    }
    finally {
        return false;
    }
}

我期待这个功能的输出true,但它是false!

我们已经看到很多关于何时以及为何使用try/ catch和try/ catch/的问题finally.我知道try/ 肯定有一个用例finally(特别是因为它是using语句实现的方式).

我们还看到了有关try/catch和异常开销的问题.

然而,我所链接的问题并没有谈到JUST try-finally的开销.

假设try块中发生的任何事情都没有异常,那么确保finally语句在离开try块时执行的开销是多少(有时是从函数返回)？

再一次,我只询问try/ finally,不catch,不抛出异常.

谢谢!

编辑:好的,我将尝试更好地展示我的用例.

我应该使用哪个,DoWithTryFinally或者DoWithoutTryFinally？

public bool DoWithTryFinally()
{
  this.IsBusy = true;

  try
  {
    if (DoLongCheckThatWillNotThrowException())
    {
      this.DebugLogSuccess();
      return true;
    }
    else
    {
      this.ErrorLogFailure();
      return false;
    }
  }
  finally
  {
    this.IsBusy = false;
  }
}

public bool DoWithoutTryFinally()
{
  this.IsBusy …

下面有一些有趣的代码:

def func1():
    try:
        return 1
    finally:
        return 2

def func2():
    try:
        raise ValueError()
    except:
        return 1
    finally:
        return 3

func1()
func2()

可以请有人解释,结果将返回这两个函数并解释原因,即描述执行的顺序

一旦你进入finally条款,是否有可能判断是否有异常？就像是:

try:
    funky code
finally:
    if ???:
        print('the funky code raised')

我想要做更像这样的事情干:

try:
    funky code
except HandleThis:
    # handle it
    raised = True
except DontHandleThis:
    raised = True
    raise
else:
    raised = False
finally:
    logger.info('funky code raised %s', raised)

我不喜欢它需要捕获一个你不打算处理的异常,只是为了设置一个标志.

由于一些评论要求MCVE中的"M"较少,因此这里有一些关于用例的更多背景知识.实际问题是关于日志记录级别的升级.

• 时髦的代码是第三方,无法更改.
• 失败异常和堆栈跟踪不包含任何有用的诊断信息,因此logger.exception在except块中使用在此处没有帮助.
• 如果引发了时髦的代码,那么我需要查看的一些信息已经被记录在DEBUG级别.我们没有也无法处理错误,但是想要升级DEBUG日志记录,因为所需的信息就在那里.
• 大多数时候,时髦的代码不会引发.我不想升级一般情况下的日志记录级别,因为它太冗长了.

因此,代码在日志捕获上下文(设置自定义处理程序以拦截日志记录)下运行,并且一些调试信息会被追溯重新记录:

try:
    with LogCapture() as log:
        funky_code()  # <-- third party badness
finally:
    mylog = mylogger.WARNING if <there was exception> else mylogger.DEBUG
    for record in log.captured:
        mylog(record.msg, record.args)

如果catch和finally块都抛出异常会发生什么？