在本文中，我们将给您介绍关于Swiftdo-try-catch语法的详细内容，并且为您解答swiftdocatch的相关问题，此外，我们还将为您提供关于''try(Aa=newA())''VS''tr

在本文中，我们将给您介绍关于Swift do-try-catch语法的详细内容，并且为您解答swift do catch的相关问题，此外，我们还将为您提供关于''try(A a = new A())'' VS ''try finally''、C++反汇编第五讲,认识C++中的Try catch语法,以及在反汇编中还原、delphi try except语句 和 try finally语句用法、delphi try except语句 和 try finally语句用法以及区别的知识。

• Swift do-try-catch语法（swift do catch）
• ''try(A a = new A())'' VS ''try finally''
• C++反汇编第五讲,认识C++中的Try catch语法,以及在反汇编中还原
• delphi try except语句 和 try finally语句用法
• delphi try except语句 和 try finally语句用法以及区别

Swift do-try-catch语法（swift do catch）

我尝试理解Swift 2中新的错误处理方法。这是我做的：我首先声明了一个错误枚举：

enum SandwichError: ErrorType {    case NotMe    case DoItYourself}

然后我声明了一个引发错误的方法（伙计们不是异常。这是一个错误。）。这是该方法：

func makeMeSandwich(names: [String: String]) throws -> String {    guard let sandwich = names["sandwich"] else {        throw SandwichError.NotMe    }    return sandwich}

问题出在呼叫方。这是调用此方法的代码：

let kitchen = ["sandwich": "ready", "breakfeast": "not ready"]do {    let sandwich = try makeMeSandwich(kitchen)    print("i eat it \(sandwich)")} catch SandwichError.NotMe {    print("Not me error")} catch SandwichError.DoItYourself {    print("do it error")}

之后，do行编译器说Errors thrown from here are not handled because the enclosingcatch is not exhaustive。但是我认为这是详尽无遗的，因为SandwichError枚举中只有两种情况。

对于常规的switch语句，swift可以理解，在处理每种情况时，它都是详尽的。

答案1

Swift 2错误处理模型有两个重要方面：详尽性和弹性。它们一起归结为您的do/
catch语句，需要捕获所有可能的错误，而不仅仅是您知道可以抛出的错误。

请注意，您并未声明函数会抛出什么类型的错误，仅声明它是否会抛出任何类型的错误。这是一个零一无穷的问题：当有人为他人（包括您将来的自己）定义一个函数供您使用时，您不必让每个函数的客户都适应您实现中的每一个变化功能，包括它可能引发的错误。您希望调用您的函数的代码能够适应这种变化。

因为您的函数无法说出它抛出的错误类型（或将来可能抛出的错误），所以catch捕获该错误的块不知道它可能抛出的错误类型。因此，除了处理您所知道的错误类型之外，您还需要使用通用catch语句来处理那些您不知道的错误类型-
这样，如果您的函数更改了将来抛出的错误集，则调用方仍将捕获该错误类型错误。

do {    let sandwich = try makeMeSandwich(kitchen)    print("i eat it \(sandwich)")} catch SandwichError.NotMe {    print("Not me error")} catch SandwichError.DoItYourself {    print("do it error")} catch let error {    print(error.localizedDescription)}

但是，我们不要就此止步。再考虑一下这种弹性思想。设计三明治的方式必须在使用它们的每个地方描述错误。这意味着，每当更改错误案例集时，都必须更改使用它们的每个位置……不是很有趣。

定义自己的错误类型的想法是让您集中诸如此类的事情。您可以description为错误定义一个方法：

extension SandwichError: CustomStringConvertible {    var description: String {        switch self {            case NotMe: return "Not me error"            case DoItYourself: return "Try sudo"        }    }}

然后，您的错误处理代码可以要求您的错误类型进行自我描述-现在，您处理错误的每个地方都可以使用相同的代码，并且还可以处理将来可能发生的错误情况。

do {    let sandwich = try makeMeSandwich(kitchen)    print("i eat it \(sandwich)")} catch let error as SandwichError {    print(error.description)} catch {    print("i dunno")}

这也为错误类型（或错误扩展）支持其他报告错误的方式铺平了道路-
例如，您可以在错误类型上拥有扩展名，该扩展名知道如何向UIAlertControlleriOS用户报告错误。

''try(A a = new A())'' VS ''try finally''

实现了AutoCloseable接口的类，可以在try的时候直接实例化对象。try代码块完成之后，自动调用close方法，相当于在finally里主动调用。但是出现异常后的流程和try finally有什么不同呢？ 下面写代码测试一下。

首先定义一个类Cat，实现AutoCloseable接口

class Cat implements AutoCloseable{
	void sayHello() throws Exception {
		Utils.println("calling sayHello(), I will throw an exception");
		throw new Exception("Exception in sayHello() ");
	}

	@Override
	public void close() throws Exception {
		Utils.println("I''m closing, I will throw an exception");
		throw new Exception("Exception in close()");
	}
}

我们的这个Cat有以下特点：

• sayHello方法会抛出异常
• close方法也会抛出异常

test v1: ''try(Cat cat = new Cat())'' VS ''try finally''

没有catch（不要被外层的catch迷惑，那只是为了打印异常）

static void testV1(){
    Utils.println("----try(Cat cat = new Cat())-----");
    try{
        try(Cat cat = new Cat()){
            cat.sayHello();
        }

    }catch (Exception e){
        Utils.println("cache error in main (" + e + "), let''s see its stack trace");
        Utils.printStackTrace(e);
    }
    Utils.println("--------------");

    Utils.println("----try finally-----");
    try{
        Cat cat = null;
        try{
            cat = new Cat();
            cat.sayHello();
        }finally {
            if(cat != null){
                cat.close();
            }
        }
    }catch (Exception e){
        Utils.println("cache error in main (" + e + "), let''s see its stack trace");
        Utils.printStackTrace(e);
    }
    Utils.println("--------------");
}

结果输出：

----test v1----------------------------------------
----try(Cat cat = new Cat())-----
calling sayHello(), I will throw an exception
I''m closing, I will throw an exception
cache error in main (java.lang.Exception: Exception in sayHello() ), let''s see its stack trace
java.lang.Exception: Exception in sayHello() 
	at Cat.sayHello(Cat.java:4)
	at Test.testV1(Test.java:16)
	at Test.main(Test.java:4)
	Suppressed: java.lang.Exception: Exception in close()
		at Cat.close(Cat.java:10)
		at Test.testV1(Test.java:17)
		... 1 more
--------------
----try finally-----
calling sayHello(), I will throw an exception
I''m closing, I will throw an exception
cache error in main (java.lang.Exception: Exception in close()), let''s see its stack trace
java.lang.Exception: Exception in close()
	at Cat.close(Cat.java:10)
	at Test.testV1(Test.java:33)
	at Test.main(Test.java:4)
--------------

结论

• try(Cat cat = new Cat())
  • try代码块完成之后会自动调用close
  • close抛出的异常，被Suppressed了，外层捕获的只有sayHello的异常，但通过堆栈可以找到这个Suppressed的异常
• try finally
  • 外层捕获的是在finally执行close时抛出的异常，sayHello的异常完全不见了。

test v2: ''try(Cat cat = new Cat()) catch{}'' VS ''try catch finally''

有catch，并且catch里再抛出异常

static void testV2(){
    Utils.println("----try(Cat cat = new Cat()) catch-----");
    try{
        try(Cat cat = new Cat()){
            cat.sayHello();
        } catch (Exception e) {
            Utils.println("cached err (" + e.getMessage() + "), I will throw an exception again");
            throw new Exception("Exception in catch", e);
        }

    }catch (Exception e){
        Utils.println("cache error in main (" + e + "), let''s see its stack trace");
        Utils.printStackTrace(e);
    }
    Utils.println("-----------------------------------------");

    Utils.println("----try catch finally--------------------");
    try{
        Cat cat = null;
        try{
            cat = new Cat();
            cat.sayHello();
        } catch (Exception e) {
            Utils.println("cached err (" + e.getMessage() + "), I will throw an exception again");
            throw new Exception("Exception in catch", e);
        }finally {
            if(cat != null){
                cat.close();
            }
        }
    }catch (Exception e){
        Utils.println("cache error in main (" + e + "), let''s see its stack trace");
        Utils.printStackTrace(e);
    }
    Utils.println("-------------------------------------------");
}

结果输出

----test v2------
----try(Cat cat = new Cat()){} catch{}-----
calling sayHello(), I will throw an exception
I''m closing, I will throw an exception
cached err (Exception in sayHello() ), I will throw an exception again
cache error in main (java.lang.Exception: Exception in catch), let''s see its stack trace
java.lang.Exception: Exception in catch
	at Test.testV2(Test.java:50)
	at Test.main(Test.java:8)
-----------------------------------------
----try catch finally--------------------
calling sayHello(), I will throw an exception
cached err (Exception in sayHello() ), I will throw an exception again
I''m closing, I will throw an exception
cache error in main (java.lang.Exception: Exception in close()), let''s see its stack trace
java.lang.Exception: Exception in close()
	at Cat.close(Cat.java:10)
	at Test.testV2(Test.java:70)
	at Test.main(Test.java:8)
-------------------------------------------
---------------------------------------------------------------------

结论

• try(Cat cat = new Cat()) catch
  • catch之前就调用了close（符合try代码块完成之后会自动调用close这个结论）
  • catch到的是sayHello的异常，close抛出的异常依然被Suppressed了
  • catch中再次抛出的异常被外层捕获
• try catch finally
  • 先走catch，再走finally，所以catch捕获的是sayHello的异常
  • catch中再次抛出的异常不见了，外层捕获的是在finally执行close时抛出的异常。

测试代码地址：https://github.com/kongxiangxin/pine/tree/master/auto-closeable

C++反汇编第五讲,认识C++中的Try catch语法,以及在反汇编中还原

int main(int argc,char* argv[])
{
    try
    {
        throw 3;//抛出3整形的异常
    }
    catch (int)
    {
        printf("%d\r\n",3);
    }
    return 0;
}

delphi try except语句 和 try finally语句用法

delphi try except语句 和 try finally语句用法以及区别

关于Swift do-try-catch语法和swift do catch的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于''try(A a = new A())'' VS ''try finally''、C++反汇编第五讲,认识C++中的Try catch语法,以及在反汇编中还原、delphi try except语句 和 try finally语句用法、delphi try except语句 和 try finally语句用法以及区别等相关知识的信息别忘了在本站进行查找喔。