blocks|key|1837113|text|Swift中没有任何例外，类似于Objective的方法.|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1837114|在开发中，您可以使用assert捕捉任何可能出现的错误，并且需要在开始生产之前进行修复。|offset|length|style|CODE|1837115|传统的NSError方法不会改变，您可以发送一个NSErrorPointer，它会被填充。|1837116|简短的例子：|1837117|var+error:+NSError?
var+contents+=+NSFileManager.defaultManager().contentsOfDirectoryAtPath("/Users/leandros",+error:+&error)
if+let+error+=+error+{
++++println("An+error+occurred+\(error)")
}+else+{
++++println("Contents:+\(contents)")
}|code-block|syntax|javascript|1837118|entityMap^0|0|A|6|0|3|7|O|E|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|W|8|@$D|X|E|Y|F|G]|$D|Z|E|10|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|11|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|12|8|@]|9|@]|A|$O|P]]|$1|Q|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|R|$]]

There are no Exceptions in Swift, similar to Objective-C's approach.

In development, you can use <code>assert</code> to catch any errors which might appear, and need to be fixed before going to production.

The classic <code>NSError</code> approach isn't altered, you send an <code>NSErrorPointer</code>, which gets populated.

Brief example: 

<pre><code>var error: NSError?
var contents = NSFileManager.defaultManager().contentsOfDirectoryAtPath("/Users/leandros", error: &amp;error)
if let error = error {
 println("An error occurred \(error)")
} else {
 println("Contents: \(contents)")
}
</code></pre>

blocks|key|1837168|text|Swift+2&3|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1837169|Swift+2中的情况发生了一些变化，因为有一种新的错误处理机制，这与异常有些相似，但细节不同。|1837170|1.指示错误的可能性|1837171|如果函数/方法想表明它可能抛出错误，那么它应该包含像下面这样的throws关键字|offset|length|style|CODE|1837172|func+summonDefaultDragon()+throws+->+Dragon|code-block|syntax|javascript|1837173|注意:函数实际上可以抛出的错误类型没有规范。这个声明只是声明函数可以抛出实现ErrorType的任何类型的实例，或者根本不抛出。|1837174|2.调用可能引发错误的函数|1837175|为了调用函数，需要使用try关键字，如下所示|1837176|try+summonDefaultDragon()|1837177|这一行通常应该在下面这样的do-catch块中。|1837178|do+{
++++let+dragon+=+try+summonDefaultDragon()+
}+catch+DragonError.dragonIsMissing+{
++++//+Some+specific-case+error-handling
}+catch+DragonError.notEnoughMana(let+manaRequired)+{
++++//+Other+specific-case+error-handlng
}+catch+{
++++//+Catch+all+error-handling
}|1837179|注意:+catch子句使用Swift模式匹配的所有强大功能，因此您在这里非常灵活。|1837180|如果要从本身标记为throws关键字的函数调用抛出函数，则可以决定传播错误：|1837181|func+fulfill(quest:+Quest)+throws+{
++++let+dragon+=+try+summonDefaultDragon()
++++quest.ride(dragon)
}+|1837182|或者，您可以使用try?调用抛出函数。|1837183|let+dragonOrNil+=+try?+summonDefaultDragon()|1837184|这样，您可以获得返回值或零(如果发生任何错误)。使用这种方式，您将不会获得error对象。|1837185|这意味着您还可以将try?与有用的语句组合起来，例如：|1837186|if+let+dragon+=+try?+summonDefaultDragon()|1837187|或|1837188|guard+let+dragon+=+try?+summonDefaultDragon()+else+{+...+}|1837189|最后，您可以确定错误不会实际发生(例如，因为您已经检查了“先决条件”)，并使用try!关键字：|1837190|let+dragon+=+try!+summonDefaultDragon()|1837191|如果函数实际上抛出了一个错误，那么您将在应用程序中得到一个运行时错误，并且应用程序将终止。|1837192|3.抛出错误|1837193|为了抛出一个错误，您可以像下面这样使用抛出关键字|1837194|throw+DragonError.dragonIsMissing|1837195|您可以抛出符合ErrorType协议的任何内容。首先，NSError符合此协议，但您可能希望使用基于枚举的ErrorType，它使您能够对多个相关错误进行分组，可能还会使用其他数据块，如下所示|1837196|enum+DragonError:+ErrorType+{
++++case+dragonIsMissing
++++case+notEnoughMana(requiredMana:+Int)
++++...
}|1837197|1837198|新的Swift+2&3错误机制与Java/C#/C%2B%2B类型异常的主要区别如下：|1837199|语法有点不同：do-catch+%2B+try+%2B+defer与传统的try-catch-finally语法不同。|unordered-list-item|1837200|异常处理通常在异常路径中比在成功路径中需要更长的执行时间。SWIFT2.0错误的情况并非如此，成功路径和错误路径的成本大致相同。|1837201|必须声明抛出代码的所有错误，而异常可能是从任何地方抛出的。所有错误都是Java术语中的“检查异常”。但是，与Java不同的是，您没有指定可能引发的错误。|1837202|Swift异常与ObjC异常不兼容。您的do-catch块不会捕获任何NSException，反之亦然，因为您必须使用ObjC。|1837203|Swift异常与Cocoa+NSError方法惯例兼容，即返回false+(用于Bool返回函数)或nil+(用于AnyObject返回函数)，并传递包含错误详细信息的NSErrorPointer。|1837204|1837205|1837206|作为一种额外的语法糖来简化错误处理，还有两个概念。|1837207|延迟操作(使用defer关键字)，它允许您实现与Java/C#/etc中的最后块相同的效果|1837208|保护语句(使用guard关键字)，它允许您编写比正常错误检查/信令代码少多少if/+let代码。|1837209|1837210|1837211|1837212|Swift+1|1837213|运行时错误：|BOLD|1837214|正如Leandros在处理运行时错误(如网络连接问题、解析数据、打开文件等)所建议的那样，您应该像在ObjC中那样使用ObjC，因为基金会、AppKit、UIKit等都以这种方式报告它们的错误。所以与其说是语言，不如说是框架。|1837215|另一个常用的模式是分隔成功/失败块，如在AFNetworking中：|1837216|var+sessionManager+=+AFHTTPSessionManager(baseURL:+NSURL(string:+"yavin4.yavin.planets"))
sessionManager.HEAD("/api/destoryDeathStar",+parameters:+xwingSquad,
++++success:+{+(NSURLSessionDataTask)+->+Void+in
++++++++println("Success")
++++},
++++failure:{+(NSURLSessionDataTask,+NSError)+->+Void+in
++++++++println("Failure")
++++})|1837217|仍然失败块经常接收NSError实例，描述错误。|1837218|程序员错误：|1837219|对于程序员错误(如数组元素的越界访问、传递给函数调用的无效参数等)，您在ObjC中使用了异常。Swift语言似乎对异常没有任何语言支持(如throw、catch等关键字)。但是，如文档所示，它运行在与ObjC相同的运行时，因此仍然能够像这样抛出NSExceptions：|1837220|NSException(name:+"SomeName",+reason:+"SomeReason",+userInfo:+nil).raise()|1837221|您只是无法在纯Swift中捕获它们，尽管您可能选择在ObjC代码中捕获异常。|1837222|问题是您是否应该为程序员错误抛出异常，或者像Apple在语言指南中建议的那样使用断言。|1837223|entityMap^0|0|0|0|V|6|0|0|0|0|0|0|0|0|0|9|6|0|0|8|4|0|0|0|9|4|0|0|0|0|13|4|0|0|0|0|0|0|7|9|R|7|1H|9|0|0|0|0|7|8|I|3|O|5|X|H|0|0|0|K|8|0|E|7|V|5|14|4|1E|3|1L|9|2C|E|0|0|0|0|7|5|0|7|5|0|0|0|0|0|0|6|0|0|0|0|9|7|0|0|6|0|1X|5|23|5|3E|C|0|0|0|0^^$0|@$1|2|3|4|5|6|7|3G|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|3H|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|3I|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|3J|8|@$H|3K|I|3L|J|K]]|9|@]|A|$]]|$1|L|3|M|5|N|7|3M|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|3N|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|3O|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|3P|8|@]|9|@]|A|$]]|$1|W|3|X|5|N|7|3Q|8|@]|9|@]|A|$O|P]]|$1|Y|3|Z|5|6|7|3R|8|@]|9|@]|A|$]]|$1|10|3|11|5|N|7|3S|8|@]|9|@]|A|$O|P]]|$1|12|3|13|5|6|7|3T|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|3U|8|@$H|3V|I|3W|J|K]]|9|@]|A|$]]|$1|16|3|17|5|N|7|3X|8|@]|9|@]|A|$O|P]]|$1|18|3|19|5|6|7|3Y|8|@$H|3Z|I|40|J|K]]|9|@]|A|$]]|$1|1A|3|1B|5|N|7|41|8|@]|9|@]|A|$O|P]]|$1|1C|3|1D|5|6|7|42|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|43|8|@$H|44|I|45|J|K]]|9|@]|A|$]]|$1|1G|3|1H|5|N|7|46|8|@]|9|@]|A|$O|P]]|$1|1I|3|1J|5|6|7|47|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|N|7|48|8|@]|9|@]|A|$O|P]]|$1|1M|3|1N|5|6|7|49|8|@$H|4A|I|4B|J|K]]|9|@]|A|$]]|$1|1O|3|1P|5|N|7|4C|8|@]|9|@]|A|$O|P]]|$1|1Q|3|1R|5|6|7|4D|8|@]|9|@]|A|$]]|$1|1S|3|1T|5|6|7|4E|8|@]|9|@]|A|$]]|$1|1U|3|1V|5|6|7|4F|8|@]|9|@]|A|$]]|$1|1W|3|1X|5|N|7|4G|8|@]|9|@]|A|$O|P]]|$1|1Y|3|1Z|5|6|7|4H|8|@$H|4I|I|4J|J|K]|$H|4K|I|4L|J|K]|$H|4M|I|4N|J|K]]|9|@]|A|$]]|$1|20|3|21|5|N|7|4O|8|@]|9|@]|A|$O|P]]|$1|22|3|-4|5|6|7|4P|8|@]|9|@]|A|$]]|$1|23|3|24|5|6|7|4Q|8|@]|9|@]|A|$]]|$1|25|3|26|5|27|7|4R|8|@$H|4S|I|4T|J|K]|$H|4U|I|4V|J|K]|$H|4W|I|4X|J|K]|$H|4Y|I|4Z|J|K]]|9|@]|A|$]]|$1|28|3|29|5|27|7|50|8|@]|9|@]|A|$]]|$1|2A|3|2B|5|27|7|51|8|@]|9|@]|A|$]]|$1|2C|3|2D|5|27|7|52|8|@$H|53|I|54|J|K]]|9|@]|A|$]]|$1|2E|3|2F|5|27|7|55|8|@$H|56|I|57|J|K]|$H|58|I|59|J|K]|$H|5A|I|5B|J|K]|$H|5C|I|5D|J|K]|$H|5E|I|5F|J|K]|$H|5G|I|5H|J|K]]|9|@]|A|$]]|$1|2G|3|-4|5|6|7|5I|8|@]|9|@]|A|$]]|$1|2H|3|-4|5|6|7|5J|8|@]|9|@]|A|$]]|$1|2I|3|2J|5|6|7|5K|8|@]|9|@]|A|$]]|$1|2K|3|2L|5|27|7|5L|8|@$H|5M|I|5N|J|K]]|9|@]|A|$]]|$1|2M|3|2N|5|27|7|5O|8|@$H|5P|I|5Q|J|K]]|9|@]|A|$]]|$1|2O|3|-4|5|6|7|5R|8|@]|9|@]|A|$]]|$1|2P|3|-4|5|6|7|5S|8|@]|9|@]|A|$]]|$1|2Q|3|-4|5|6|7|5T|8|@]|9|@]|A|$]]|$1|2R|3|2S|5|6|7|5U|8|@]|9|@]|A|$]]|$1|2T|3|2U|5|6|7|5V|8|@$H|5W|I|5X|J|2V]]|9|@]|A|$]]|$1|2W|3|2X|5|6|7|5Y|8|@]|9|@]|A|$]]|$1|2Y|3|2Z|5|6|7|5Z|8|@]|9|@]|A|$]]|$1|30|3|31|5|N|7|60|8|@]|9|@]|A|$O|P]]|$1|32|3|33|5|6|7|61|8|@$H|62|I|63|J|K]]|9|@]|A|$]]|$1|34|3|35|5|6|7|64|8|@$H|65|I|66|J|2V]]|9|@]|A|$]]|$1|36|3|37|5|6|7|67|8|@$H|68|I|69|J|K]|$H|6A|I|6B|J|K]|$H|6C|I|6D|J|K]]|9|@]|A|$]]|$1|38|3|39|5|N|7|6E|8|@]|9|@]|A|$O|P]]|$1|3A|3|3B|5|6|7|6F|8|@]|9|@]|A|$]]|$1|3C|3|3D|5|6|7|6G|8|@]|9|@]|A|$]]|$1|3E|3|-4|5|6|7|6H|8|@]|9|@]|A|$]]]|3F|$]]

<h2>Swift 2 & 3</h2>

Things have changed a bit in Swift 2, as there is a new error-handling mechanism, that is somewhat more similar to exceptions but different in detail.

<h3>1. Indicating error possibility</h3>

If function/method wants to indicate that it may throw an error, it should contain <code>throws</code> keyword like this 

<pre><code>func summonDefaultDragon() throws -&gt; Dragon
</code></pre>

Note: there is no specification for type of error the function actually can throw. This declaration simply states that the function can throw an instance of any type implementing ErrorType or is not throwing at all.

<h3>2. Invoking function that may throw errors</h3>

In order to invoke function you need to use try keyword, like this

<pre><code>try summonDefaultDragon()
</code></pre>

this line should normally be present do-catch block like this

<pre><code>do {
 let dragon = try summonDefaultDragon() 
} catch DragonError.dragonIsMissing {
 // Some specific-case error-handling
} catch DragonError.notEnoughMana(let manaRequired) {
 // Other specific-case error-handlng
} catch {
 // Catch all error-handling
}
</code></pre>

Note: catch clause use all the powerful features of Swift pattern matching so you are very flexible here.

You may decided to propagate the error, if your are calling a throwing function from a function that is itself marked with <code>throws</code> keyword:

<pre><code>func fulfill(quest: Quest) throws {
 let dragon = try summonDefaultDragon()
 quest.ride(dragon)
} 
</code></pre>

Alternatively, you can call throwing function using <code>try?</code>:

<pre><code>let dragonOrNil = try? summonDefaultDragon()
</code></pre>

This way you either get the return value or nil, if any error occurred. Using this way you do not get the error object.

Which means that you can also combine <code>try?</code> with useful statements like:

<pre><code>if let dragon = try? summonDefaultDragon()
</code></pre>

or

<pre><code>guard let dragon = try? summonDefaultDragon() else { ... }
</code></pre>

Finally, you can decide that you know that error will not actually occur (e.g. because you have already checked are prerequisites) and use <code>try!</code> keyword:

<pre><code>let dragon = try! summonDefaultDragon()
</code></pre>

If the function actually throws an error, then you'll get a runtime error in your application and the application will terminate.

<h3>3. Throwing an error</h3>

In order to throw an error you use throw keyword like this

<pre><code>throw DragonError.dragonIsMissing
</code></pre>

You can throw anything that conforms to <code>ErrorType</code> protocol. For starters <code>NSError</code> conforms to this protocol but you probably would like to go with enum-based <code>ErrorType</code> which enables you to group multiple related errors, potentially with additional pieces of data, like this

<pre><code>enum DragonError: ErrorType {
 case dragonIsMissing
 case notEnoughMana(requiredMana: Int)
 ...
}
</code></pre>

<hr>

Main differences between new Swift 2 &amp; 3 error mechanism and Java/C#/C++ style exceptions are follows:

<ul>
<li>Syntax is a bit different: <code>do-catch</code> + <code>try</code> + <code>defer</code> vs traditional <code>try-catch-finally</code> syntax.</li>
<li>Exception handling usually incurs much higher execution time in exception path than in success path. This is not the case with Swift 2.0 errors, where success path and error path cost roughly the same.</li>
<li>All error throwing code must be declared, while exceptions might have been thrown from anywhere. All errors are "checked exceptions" in Java nomenclature. However, in contrast to Java, you do not specify potentially thrown errors.</li>
<li>Swift exceptions are not compatible with ObjC exceptions. Your <code>do-catch</code> block will not catch any NSException, and vice versa, for that you must use ObjC.</li>
<li>Swift exceptions are compatible with Cocoa <code>NSError</code> method conventions of returning either <code>false</code> (for <code>Bool</code> returning functions) or <code>nil</code> (for <code>AnyObject</code> returning functions) and passing <code>NSErrorPointer</code> with error details.</li>
</ul>

As an extra syntatic-sugar to ease error handling, there are two more concepts

<ul>
<li>deferred actions (using <code>defer</code> keyword) which let you achieve the same effect as finally blocks in Java/C#/etc</li>
<li>guard statement (using <code>guard</code> keyword) which let you write little less if/else code than in normal error checking/signaling code.</li>
</ul>

<hr>

<h2>Swift 1</h2>

Runtime errors:

As Leandros suggests for handling runtime errors (like network connectivity problems, parsing data, opening file, etc) you should use <code>NSError</code> like you did in ObjC, because the Foundation, AppKit, UIKit, etc report their errors in this way. So it's more framework thing than language thing.

Another frequent pattern that is being used are separator success/failure blocks like in AFNetworking:

<pre><code>var sessionManager = AFHTTPSessionManager(baseURL: NSURL(string: "yavin4.yavin.planets"))
sessionManager.HEAD("/api/destoryDeathStar", parameters: xwingSquad,
 success: { (NSURLSessionDataTask) -&gt; Void in
 println("Success")
 },
 failure:{ (NSURLSessionDataTask, NSError) -&gt; Void in
 println("Failure")
 })
</code></pre>

Still the failure block frequently received <code>NSError</code> instance, describing the error.

Programmer errors:

For programmer errors (like out of bounds access of array element, invalid arguments passed to a function call, etc) you used exceptions in ObjC. Swift language does not seem to have any language support for exceptions (like <code>throw</code>, <code>catch</code>, etc keyword). However, as documentation suggests it is running on the same runtime as ObjC, and therefore you are still able to throw <code>NSExceptions</code> like this:

<pre><code>NSException(name: "SomeName", reason: "SomeReason", userInfo: nil).raise()
</code></pre>

You just cannot catch them in pure Swift, although you may opt for catching exceptions in ObjC code.

The questions is whether you should throw exceptions for programmer errors, or rather use assertions as Apple suggests in the language guide.

blocks|key|1662013|text|编辑：虽然这个答案有效，但它只不过是目的-C音译成Swift。它已被SWIFT2.0中的更改所淘汰。Guilherme+Torres+Castro上面的回答是对Swift中错误处理方法的一个很好的介绍。VOS|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1662014|它花了一点时间才弄明白，但我想我已经研究过了。不过看上去很难看。只是一个薄薄的皮肤之上的目标-C版本。|1662015|使用NSError参数调用函数.|1662016|var+fooError+:+NSError+?+=+nil

let+someObject+=+foo(aParam,+error:&fooError)

//+Check+something+was+returned+and+look+for+an+error+if+it+wasn't.
if+!someObject+{
+++if+let+error+=+fooError+{
++++++//+Handle+error
++++++NSLog("This+happened:+\(error.localizedDescription)")
+++}
}+else+{
+++//+Handle+success
}`|code-block|syntax|javascript|1662017|编写接受错误参数的函数..。|1662018|func+foo(param:ParamObject,+error:+NSErrorPointer)+->+SomeObject+{

+++//+Do+stuff...

+++if+somethingBadHasHappened+{
++++++if+error+{
+++++++++error.memory+=+NSError(domain:+domain,+code:+code,+userInfo:+[:])
++++++}
++++++return+nil
+++}

+++//+Do+more+stuff...
}|1662019|entityMap^0|0|3|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|Y|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|Z|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|10|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|11|8|@]|D|@]|E|$M|N]]|$1|S|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|T|$]]

Edit: Although this answer works, it is little more than Objective-C transliterated into Swift. It has been made obsolete by changes in Swift 2.0. Guilherme Torres Castro's answer above is a very good introduction to the preferred way of handling errors in Swift. VOS

It took a bit of figuring it out but I think I've sussed it. It seems ugly though. Nothing more than a thin skin over the Objective-C version.

Calling a function with an NSError parameter...

<pre><code>var fooError : NSError ? = nil

let someObject = foo(aParam, error:&amp;fooError)

// Check something was returned and look for an error if it wasn't.
if !someObject {
 if let error = fooError {
 // Handle error
 NSLog("This happened: \(error.localizedDescription)")
 }
} else {
 // Handle success
}`
</code></pre>

Writing the function that takes an error parameter...

<pre><code>func foo(param:ParamObject, error: NSErrorPointer) -&gt; SomeObject {

 // Do stuff...

 if somethingBadHasHappened {
 if error {
 error.memory = NSError(domain: domain, code: code, userInfo: [:])
 }
 return nil
 }

 // Do more stuff...
}
</code></pre>

blocks|key|1837337|text|目标C的基本包装器，它为您提供了try+catch特性。https://github.com/williamFalcon/SwiftTryCatch|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1837338|使用方式如下：|1837339|SwiftTryCatch.try({+()+->+Void+in
++++++++//try+something
+++++},+catch:+{+(error)+->+Void+in
++++++++//handle+error
+++++},+finally:+{+()+->+Void+in
++++++++//close+resources
})|code-block|syntax|javascript|1837340|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/williamFalcon/SwiftTryCatch^0|S|1A|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Basic wrapper around objective C that gives you the try catch feature.
<a href="https://github.com/williamFalcon/SwiftTryCatch" rel="noreferrer">https://github.com/williamFalcon/SwiftTryCatch</a>

Use like:

<pre><code>SwiftTryCatch.try({ () -&gt; Void in
 //try something
 }, catch: { (error) -&gt; Void in
 //handle error
 }, finally: { () -&gt; Void in
 //close resources
})
</code></pre>

blocks|key|1139543|text|推荐的“快速方式”是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1139544|func+write(path:+String)(#error:+NSErrorPointer)+->+Bool+{+//+Useful+to+curry+error+parameter+for+retrying+(see+below)!
++++return+"Hello!".writeToFile(path,+atomically:+false,+encoding:+NSUTF8StringEncoding,+error:+error)
}

var+writeError:+NSError?
let+written+=+write("~/Error1")(error:+&writeError)
if+!written+{
++++println("write+failure+1:+\(writeError!.localizedDescription)")
++++//+assert(false)+//+Terminate+program
}|code-block|syntax|javascript|1139545|然而，我更喜欢尝试/捕捉，因为我发现它更容易跟踪，因为它将错误处理移动到另一个块的末尾，这种安排有时被称为“黄金路径”。幸运的是，您可以使用闭包来完成这一任务：|1139546|TryBool+{
++++write("~/Error2")(error:+$0)+//+The+code+to+try
}.catch+{
++++println("write+failure+2:+\($0!.localizedDescription)")+//+Report+failure
++++//+assert(false)+//+Terminate+program
}|1139547|此外，添加重试工具也很容易：|1139548|TryBool+{
++++write("~/Error3")(error:+$0)+//+The+code+to+try
}.retry+{
++++println("write+failure+3+on+try+\($1+%2B+1):+\($0!.localizedDescription)")
++++return+write("~/Error3r")++//+The+code+to+retry
}.catch+{
++++println("write+failure+3+catch:+\($0!.localizedDescription)")+//+Report+failure
++++//+assert(false)+//+Terminate+program
}|1139549|TryBool的清单是：|1139550|class+TryBool+{
++++typealias+Tryee+=+NSErrorPointer+->+Bool
++++typealias+Catchee+=+NSError?+->+()
++++typealias+Retryee+=+(NSError?,+UInt)+->+Tryee

++++private+var+tryee:+Tryee
++++private+var+retries:+UInt+=+0
++++private+var+retryee:+Retryee?

++++init(tryee:+Tryee)+{
++++++++self.tryee+=+tryee
++++}

++++func+retry(retries:+UInt,+retryee:+Retryee)+->+Self+{
++++++++self.retries+=+retries
++++++++self.retryee+=+retryee
++++++++return+self
++++}
++++func+retry(retryee:+Retryee)+->+Self+{
++++++++return+self.retry(1,+retryee)
++++}
++++func+retry(retries:+UInt)+->+Self+{
++++++++//+For+some+reason+you+can't+write+the+body+as+"return+retry(1,+nil)",+the+compiler+doesn't+like+the+nil
++++++++self.retries+=+retries
++++++++retryee+=+nil
++++++++return+self
++++}
++++func+retry()+->+Self+{
++++++++return+retry(1)
++++}

++++func+catch(catchee:+Catchee)+{
++++++++var+error:+NSError?
++++++++for+numRetries+in+0...retries+{+//+First+try+is+retry+0
++++++++++++error+=+nil
++++++++++++let+result+=+tryee(&error)
++++++++++++if+result+{
++++++++++++++++return
++++++++++++}+else+if+numRetries+!=+retries+{
++++++++++++++++if+let+r+=+retryee+{
++++++++++++++++++++tryee+=+r(error,+numRetries)
++++++++++++++++}
++++++++++++}
++++++++}
++++++++catchee(error)
++++}
}|1139551|您可以编写类似的类来测试可选的返回值，而不是Bool值：|1139552|class+TryOptional<T>+{
++++typealias+Tryee+=+NSErrorPointer+->+T?
++++typealias+Catchee+=+NSError?+->+T
++++typealias+Retryee+=+(NSError?,+UInt)+->+Tryee

++++private+var+tryee:+Tryee
++++private+var+retries:+UInt+=+0
++++private+var+retryee:+Retryee?

++++init(tryee:+Tryee)+{
++++++++self.tryee+=+tryee
++++}

++++func+retry(retries:+UInt,+retryee:+Retryee)+->+Self+{
++++++++self.retries+=+retries
++++++++self.retryee+=+retryee
++++++++return+self
++++}
++++func+retry(retryee:+Retryee)+->+Self+{
++++++++return+retry(1,+retryee)
++++}
++++func+retry(retries:+UInt)+->+Self+{
++++++++//+For+some+reason+you+can't+write+the+body+as+"return+retry(1,+nil)",+the+compiler+doesn't+like+the+nil
++++++++self.retries+=+retries
++++++++retryee+=+nil
++++++++return+self
++++}
++++func+retry()+->+Self+{
++++++++return+retry(1)
++++}

++++func+catch(catchee:+Catchee)+->+T+{
++++++++var+error:+NSError?
++++++++for+numRetries+in+0...retries+{
++++++++++++error+=+nil
++++++++++++let+result+=+tryee(&error)
++++++++++++if+let+r+=+result+{
++++++++++++++++return+r
++++++++++++}+else+if+numRetries+!=+retries+{
++++++++++++++++if+let+r+=+retryee+{
++++++++++++++++++++tryee+=+r(error,+numRetries)
++++++++++++++++}
++++++++++++}
++++++++}
++++++++return+catchee(error)
++++}
}|1139553|TryOptional版本强制执行一种非可选的返回类型，使后续编程更容易。“快速的方式：|1139554|struct+FailableInitializer+{
++++init?(_+id:+Int,+error:+NSErrorPointer)+{
++++++++//+Always+fails+in+example
++++++++if+error+!=+nil+{
++++++++++++error.memory+=+NSError(domain:+"",+code:+id,+userInfo:+[:])
++++++++}
++++++++return+nil
++++}
++++private+init()+{
++++++++//+Empty+in+example
++++}
++++static+let+fallback+=+FailableInitializer()
}

func+failableInitializer(id:+Int)(#error:+NSErrorPointer)+->+FailableInitializer?+{+//+Curry+for+retry
++++return+FailableInitializer(id,+error:+error)
}

var+failError:+NSError?
var+failure1Temp+=+failableInitializer(1)(error:+&failError)
if+failure1Temp+==+nil+{
++++println("failableInitializer+failure+code:+\(failError!.code)")
++++failure1Temp+=+FailableInitializer.fallback
}
let+failure1+=+failure1Temp!+//+Unwrap|1139555|使用TryOptional：|1139556|let+failure2+=+TryOptional+{
++++failableInitializer(2)(error:+$0)
}.catch+{
++++println("failableInitializer+failure+code:+\($0!.code)")
++++return+FailableInitializer.fallback
}

let+failure3+=+TryOptional+{
++++failableInitializer(3)(error:+$0)
}.retry+{
++++println("failableInitializer+failure,+on+try+\($1+%2B+1),+code:+\($0!.code)")
++++return+failableInitializer(31)
}.catch+{
++++println("failableInitializer+failure+code:+\($0!.code)")
++++return+FailableInitializer.fallback
}|1139557|注意自动展开。|1139558|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1A|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1C|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1G|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1H|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1J|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|1K|8|@]|9|@]|A|$]]|$1|12|3|13|5|D|7|1L|8|@]|9|@]|A|$E|F]]|$1|14|3|15|5|6|7|1M|8|@]|9|@]|A|$]]|$1|16|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|17|$]]

The recommended 'Swift Way' is:

<pre><code>func write(path: String)(#error: NSErrorPointer) -&gt; Bool { // Useful to curry error parameter for retrying (see below)!
 return "Hello!".writeToFile(path, atomically: false, encoding: NSUTF8StringEncoding, error: error)
}

var writeError: NSError?
let written = write("~/Error1")(error: &amp;writeError)
if !written {
 println("write failure 1: \(writeError!.localizedDescription)")
 // assert(false) // Terminate program
}
</code></pre>

However I prefer try/catch as I find it easier to follow because it moves the error handling to a separate block at the end, this arrangement is sometimes called "Golden Path". Lucky you can do this with closures:

<pre><code>TryBool {
 write("~/Error2")(error: $0) // The code to try
}.catch {
 println("write failure 2: \($0!.localizedDescription)") // Report failure
 // assert(false) // Terminate program
}
</code></pre>

Also it is easy to add a retry facility:

<pre><code>TryBool {
 write("~/Error3")(error: $0) // The code to try
}.retry {
 println("write failure 3 on try \($1 + 1): \($0!.localizedDescription)")
 return write("~/Error3r") // The code to retry
}.catch {
 println("write failure 3 catch: \($0!.localizedDescription)") // Report failure
 // assert(false) // Terminate program
}
</code></pre>

The listing for TryBool is:

<pre><code>class TryBool {
 typealias Tryee = NSErrorPointer -&gt; Bool
 typealias Catchee = NSError? -&gt; ()
 typealias Retryee = (NSError?, UInt) -&gt; Tryee

 private var tryee: Tryee
 private var retries: UInt = 0
 private var retryee: Retryee?

 init(tryee: Tryee) {
 self.tryee = tryee
 }

 func retry(retries: UInt, retryee: Retryee) -&gt; Self {
 self.retries = retries
 self.retryee = retryee
 return self
 }
 func retry(retryee: Retryee) -&gt; Self {
 return self.retry(1, retryee)
 }
 func retry(retries: UInt) -&gt; Self {
 // For some reason you can't write the body as "return retry(1, nil)", the compiler doesn't like the nil
 self.retries = retries
 retryee = nil
 return self
 }
 func retry() -&gt; Self {
 return retry(1)
 }

 func catch(catchee: Catchee) {
 var error: NSError?
 for numRetries in 0...retries { // First try is retry 0
 error = nil
 let result = tryee(&amp;error)
 if result {
 return
 } else if numRetries != retries {
 if let r = retryee {
 tryee = r(error, numRetries)
 }
 }
 }
 catchee(error)
 }
}
</code></pre>

You can write a similar class for testing an Optional returned value instead of Bool value:

<pre><code>class TryOptional&lt;T&gt; {
 typealias Tryee = NSErrorPointer -&gt; T?
 typealias Catchee = NSError? -&gt; T
 typealias Retryee = (NSError?, UInt) -&gt; Tryee

 private var tryee: Tryee
 private var retries: UInt = 0
 private var retryee: Retryee?

 init(tryee: Tryee) {
 self.tryee = tryee
 }

 func retry(retries: UInt, retryee: Retryee) -&gt; Self {
 self.retries = retries
 self.retryee = retryee
 return self
 }
 func retry(retryee: Retryee) -&gt; Self {
 return retry(1, retryee)
 }
 func retry(retries: UInt) -&gt; Self {
 // For some reason you can't write the body as "return retry(1, nil)", the compiler doesn't like the nil
 self.retries = retries
 retryee = nil
 return self
 }
 func retry() -&gt; Self {
 return retry(1)
 }

 func catch(catchee: Catchee) -&gt; T {
 var error: NSError?
 for numRetries in 0...retries {
 error = nil
 let result = tryee(&amp;error)
 if let r = result {
 return r
 } else if numRetries != retries {
 if let r = retryee {
 tryee = r(error, numRetries)
 }
 }
 }
 return catchee(error)
 }
}
</code></pre>

The TryOptional version enforces a non-Optional return type that makes subsequent programming easier, e.g. 'Swift Way:

<pre><code>struct FailableInitializer {
 init?(_ id: Int, error: NSErrorPointer) {
 // Always fails in example
 if error != nil {
 error.memory = NSError(domain: "", code: id, userInfo: [:])
 }
 return nil
 }
 private init() {
 // Empty in example
 }
 static let fallback = FailableInitializer()
}

func failableInitializer(id: Int)(#error: NSErrorPointer) -&gt; FailableInitializer? { // Curry for retry
 return FailableInitializer(id, error: error)
}

var failError: NSError?
var failure1Temp = failableInitializer(1)(error: &amp;failError)
if failure1Temp == nil {
 println("failableInitializer failure code: \(failError!.code)")
 failure1Temp = FailableInitializer.fallback
}
let failure1 = failure1Temp! // Unwrap
</code></pre>

Using TryOptional:

<pre><code>let failure2 = TryOptional {
 failableInitializer(2)(error: $0)
}.catch {
 println("failableInitializer failure code: \($0!.code)")
 return FailableInitializer.fallback
}

let failure3 = TryOptional {
 failableInitializer(3)(error: $0)
}.retry {
 println("failableInitializer failure, on try \($1 + 1), code: \($0!.code)")
 return failableInitializer(31)
}.catch {
 println("failableInitializer failure code: \($0!.code)")
 return FailableInitializer.fallback
}
</code></pre>

Note auto-unwrapping.

blocks|key|1139574|text|处理异常的很好的简单库：TryCatchFinally-Swift|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1139575|和其他一些类似，它围绕着目标C异常特性。|1139576|像这样使用它：|1139577|try+{
++++println("++try")
}.catch+{+e+in
++++println("++catch")
}.finally+{
++++println("++finally")
}|code-block|syntax|javascript|1139578|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/kongtomorrow/TryCatchFinally-Swift^0|C|L|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|C|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Nice and simple lib to handle exception:
<a href="https://github.com/kongtomorrow/TryCatchFinally-Swift" rel="nofollow">TryCatchFinally-Swift</a>

Like a few others it wraps around the objective C exception features.

Use it like this:

<pre><code>try {
 println(" try")
}.catch { e in
 println(" catch")
}.finally {
 println(" finally")
}
</code></pre>

blocks|key|1837403|text|这是快速2.0的更新答案。我期待特性丰富的错误处理模型，如在java。最后，他们宣布了这个好消息。here|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1837404|错误处理模型:SWIFT2.0中的新错误处理模型将立即感觉自然，熟悉的尝试、抛出和捕获关键字。最棒的是，它的设计是与苹果的SDK和NSError完美地工作。事实上，NSError符合Swift的ErrorType。你一定会想看WWDC的会议关于什么是新的在斯威夫特，以了解更多有关它。
|blockquote|style|BOLD|1837405|1837406|例如：|1837407|func+loadData()+throws+{+}
func+test()+{
do+{
++++try+loadData()
}+catch+{
++++print(error)
}}|code-block|syntax|javascript|1837408|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.apple.com/swift/blog/?id=29^0|1D|4|0|0|Z|B|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|F|7|12|8|@$A|13|B|14|G|H]]|9|@]|C|$]]|$1|I|3|-4|5|6|7|15|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|16|8|@]|9|@]|C|$]]|$1|L|3|M|5|N|7|17|8|@]|9|@]|C|$O|P]]|$1|Q|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

This is an update answer for swift 2.0. I am looking forward feature rich Error handling model like in java. Finally, they announced the good news. <a href="https://developer.apple.com/swift/blog/?id=29" rel="nofollow">here</a>

<blockquote>
 Error handling model: The new error handling model in Swift 2.0 will
 instantly feel natural, with familiar try, throw, and catch keywords.
 Best of all, it was designed to work perfectly with the Apple SDKs and
 NSError. In fact, NSError conforms to a Swift’s ErrorType. You’ll
 definitely want to watch the WWDC session on What’s New in Swift to
 hear more about it.
</blockquote>

e.g :

<pre><code>func loadData() throws { }
func test() {
do {
 try loadData()
} catch {
 print(error)
}}
</code></pre>

blocks|key|1662080|text|我看到的是，由于设备的性质，您不想向用户抛出一堆神秘的错误处理消息。这就是为什么大多数函数返回可选值的原因，然后您只需要编写代码来忽略可选值。如果一个函数返回为零，这意味着它失败了，您可以弹出一条消息或其他什么。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1662081|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

What I have seen is that because of the nature of the device you don't want to be throwing a bunch of cryptic error handling messages at the user. That is why most functions return optional values then you just code to ignore the optional. If a function comes back nil meaning it failed you can pop a message or whatever.

blocks|key|1837488|text|错误处理是SWIFT2.0的一个新特性。它使用try、throw和catch关键字。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1837489|见Apple+Swift+2.0+announcement+on+the+official+Apple+Swift+blog|1837490|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.apple.com/swift/blog/?id=29^0|N|3|R|5|X|5|0|1|1P|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|H|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

Error handling is a new feature of Swift 2.0. It uses the <code>try</code>, <code>throw</code> and <code>catch</code> keywords.

See the <a href="https://developer.apple.com/swift/blog/?id=29" rel="nofollow">Apple Swift 2.0 announcement on the official Apple Swift blog</a>

blocks|key|1139680|text|正如Guilherme所说，在SWIFT2.0中，try、catch、do可以用于编程。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1139681|例如，在CoreData提取数据方法中，我们不需要将&error作为参数放入managedContext.executeFetchRequest(fetchRequest,+error:+&error)中，而是只需要使用managedContext.executeFetchRequest(fetchRequest)，然后使用try，catch+(Apple+Document+Link)来处理错误。|1139682|do+{
+++let+fetchedResults+=+try+managedContext.executeFetchRequest(fetchRequest)+as?+[NSManagedObject]
+++if+let+results+=+fetchedResults{
++++++people+=+results
+++}
}+catch+{
+++print("Could+not+fetch")
}|code-block|syntax|javascript|1139683|如果您已经下载了xcode7+Beta。尝试搜索文档和API引用中的抛出错误，并选择第一个显示结果，为这种新语法提供了一个基本思路。然而，还没有为许多API发布完整的文档。|1139684|更复杂的错误处理技术可以在|1139685|Swift中的新事物(2015年会议106、28、30)|blockquote|1139686|1139687|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.apple.com/library/prerelease/ios/documentation/Cocoa/Reference/CoreDataFramework/Classes/NSManagedObjectContext_Class/index.html#//apple_ref/occ/instm/NSManagedObjectContext/executeFetchRequest:error:^0|P|3|T|5|Z|2|0|Q|6|12|1R|32|1C|4J|3|4N|5|4U|J|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]]|D|@$9|1K|A|1L|1|1M]]|E|$]]|$1|H|3|I|5|J|7|1N|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1O|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1P|8|@]|D|@]|E|$]]|$1|Q|3|R|5|S|7|1Q|8|@]|D|@]|E|$]]|$1|T|3|-4|5|6|7|1R|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1S|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|11]]]]

As Guilherme Torres Castro said, in Swift 2.0, <code>try</code>, <code>catch</code>, <code>do</code> can be used in the programming.

For example, In CoreData fetch data method, instead of put <code>&amp;error</code> as a parameter into the <code>managedContext.executeFetchRequest(fetchRequest, error: &amp;error)</code>, now we only need to use use <code>managedContext.executeFetchRequest(fetchRequest)</code> and then handle the error with <code>try</code>, <code>catch</code> (<a href="https://developer.apple.com/library/prerelease/ios/documentation/Cocoa/Reference/CoreDataFramework/Classes/NSManagedObjectContext_Class/index.html#//apple_ref/occ/instm/NSManagedObjectContext/executeFetchRequest:error:" rel="nofollow">Apple Document Link</a>) 

<pre><code>do {
 let fetchedResults = try managedContext.executeFetchRequest(fetchRequest) as? [NSManagedObject]
 if let results = fetchedResults{
 people = results
 }
} catch {
 print("Could not fetch")
}
</code></pre>

If you have already download the xcode7 Beta. Try to search throwing errors in Documentations and API Reference and choose the first showing result, it gives a basic idea what can be done for this new syntax. However, fully documentation is not post for many APIs yet. 

More fancy Error Handling techniques can be found in 

<blockquote>
 What's New in Swift (2015 Session 106 28m30s)
</blockquote>

blocks|key|1837556|text|从Swift+2开始，正如其他人已经提到的，错误处理最好通过使用do/try/catch和ErrorType枚举来完成。这对于同步方法很好，但是异步错误处理需要一点聪明。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1837557|本文有一个很好的方法来解决这个问题：|1837558|https://jeremywsherman.com/blog/2015/06/17/using-swift-throws-with-completion-callbacks/|offset|length|1837559|概括地说：|1837560|//+create+a+typealias+used+in+completion+blocks,+for+cleaner+code
typealias+LoadDataResult+=+()+throws+->+NSData

//+notice+the+reference+to+the+typealias+in+the+completionHandler
func+loadData(someID:+String,+completionHandler:+LoadDataResult+->+Void)
++++{
++++completionHandler()
++++}|code-block|syntax|javascript|1837561|然后，对上述方法的调用如下：|1837562|self.loadData("someString",
++++completionHandler:+++++
++++++++{+result:+LoadDataResult+in
++++++++do
++++++++++++{
++++++++++++let+data+=+try+result()
++++++++++++//+success+-+go+ahead+and+work+with+the+data
++++++++++++}
++++++++catch
++++++++++++{
++++++++++++//+failure+-+look+at+the+error+code+and+handle+accordingly
++++++++++++}
++++++++})|1837563|这似乎比将单独的errorHandler回调传递给异步函数要简单一些，这是Swift+2之前的处理方式。|1837564|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|2G|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|13|8|@]|9|@$F|14|G|15|1|16]]|A|$]]|$1|H|3|I|5|6|7|17|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|18|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|19|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1A|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1B|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|E]]]]

Starting with Swift 2, as others have already mentioned, error handling is best accomplished through the use of do/try/catch and ErrorType enums. This works quite well for synchronous methods, but a little cleverness is required for asynchronous error handling.

This article has a great approach to this problem:

<a href="https://jeremywsherman.com/blog/2015/06/17/using-swift-throws-with-completion-callbacks/" rel="nofollow">https://jeremywsherman.com/blog/2015/06/17/using-swift-throws-with-completion-callbacks/</a>

To summarize:

<pre><code>// create a typealias used in completion blocks, for cleaner code
typealias LoadDataResult = () throws -&gt; NSData

// notice the reference to the typealias in the completionHandler
func loadData(someID: String, completionHandler: LoadDataResult -&gt; Void)
 {
 completionHandler()
 }
</code></pre>

then, the call to the above method would be as follows:

<pre><code>self.loadData("someString",
 completionHandler: 
 { result: LoadDataResult in
 do
 {
 let data = try result()
 // success - go ahead and work with the data
 }
 catch
 {
 // failure - look at the error code and handle accordingly
 }
 })
</code></pre>

This seems a bit cleaner than having a separate errorHandler callback passed to the asynchronous function, which was how this would be handled prior to Swift 2.

blocks|key|1662116|text|enum+CheckValidAge+:+Error{
++++case+overrage
++++case+underage
}

func+checkValidAgeForGovernmentJob(age:Int)throws+->+Bool{
++++if+age+<+18{
++++++++throw+CheckValidAge.underage
++++}else++if+age+>+25{
++++++++throw++CheckValidAge.overrage
++++}else{
++++++++return+true
++++}
}

do+{
++++try+checkValidAgeForGovernmentJob(age:+26)
++++print("You+are+valid+for+government+job+")
}catch+CheckValidAge.underage{
++++print("You+are+underage+for+government+job+")
}catch+CheckValidAge.overrage{
++++print("You+are+overrage+for+government+job+")
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1662117|在try+checkValidAgeForGovernmentJob中更改年龄(年龄:+26)
|blockquote|1662118|unstyled|1662119|你对政府的工作太过分了|1662120|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|-4|5|H|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|H|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|H|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>enum CheckValidAge : Error{
 case overrage
 case underage
}

func checkValidAgeForGovernmentJob(age:Int)throws -&gt; Bool{
 if age &lt; 18{
 throw CheckValidAge.underage
 }else if age &gt; 25{
 throw CheckValidAge.overrage
 }else{
 return true
 }
}

do {
 try checkValidAgeForGovernmentJob(age: 26)
 print(&quot;You are valid for government job &quot;)
}catch CheckValidAge.underage{
 print(&quot;You are underage for government job &quot;)
}catch CheckValidAge.overrage{
 print(&quot;You are overrage for government job &quot;)
}
</code></pre>
<blockquote>
Change age in try checkValidAgeForGovernmentJob(age: 26)
</blockquote>
Out Put
You are overrage for government job

I haven't read too much into Swift but one thing I noticed is that there are no exceptions.
So how do they do error handling in Swift? Has anyone found anything related to error-handling?

Error-Handling in Swift-Language

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我没有读太多关于Swift的文章，但有一件事我注意到，没有例外。那么，他们如何在Swift中进行错误处理呢？有没有人发现任何与错误处理有关的东西？

问Swift语言中的错误处理
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Swift语言中的错误处理EN