我对Swift的了解还不够多,但是我注意到的一件事是没有例外。那么如何在Swift中进行错误处理呢?有没有人发现任何与错误处理相关的信息?
我对Swift的了解还不够多,但是我注意到的一件事是没有例外。那么如何在Swift中进行错误处理呢?有没有人发现任何与错误处理相关的信息?
Answers:
Swift 2中的情况有所变化,因为有一个新的错误处理机制,该机制与异常有些相似,但在细节上有所不同。
如果函数/方法想要表明它可能抛出错误,则应包含这样的throws
关键字
func summonDefaultDragon() throws -> Dragon
注意:函数没有实际抛出的错误类型的规范。该声明仅声明该函数可以抛出实现ErrorType的任何类型的实例,或者根本不抛出该实例。
为了调用函数,您需要使用try关键字,像这样
try summonDefaultDragon()
该行通常应该像这样出现在do-catch块中
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
}
注意:catch子句使用Swift模式匹配的所有强大功能,因此您在这里非常灵活。
如果您正在从本身用throws
关键字标记的函数中调用throwing函数,则可以决定传播错误:
func fulfill(quest: Quest) throws {
let dragon = try summonDefaultDragon()
quest.ride(dragon)
}
另外,您可以使用try?
以下命令调用throwing函数:
let dragonOrNil = try? summonDefaultDragon()
这样,如果发生任何错误,您将获得返回值或nil。使用这种方式,您不会得到错误对象。
这意味着您还可以结合以下try?
有用的语句:
if let dragon = try? summonDefaultDragon()
要么
guard let dragon = try? summonDefaultDragon() else { ... }
最后,您可以决定知道实际上不会发生错误(例如,因为您已经检查过先决条件),并使用try!
关键字:
let dragon = try! summonDefaultDragon()
如果该函数实际引发错误,则您的应用程序中将出现运行时错误,并且该应用程序将终止。
为了引发错误,您可以使用throw这样的关键字
throw DragonError.dragonIsMissing
您可以抛出任何符合ErrorType
协议的内容。对于初学者来说,NSError
遵循此协议,但是您可能希望使用基于枚举的枚举,ErrorType
它可以将多个相关的错误归为一组,可能还包含其他数据,例如
enum DragonError: ErrorType {
case dragonIsMissing
case notEnoughMana(requiredMana: Int)
...
}
新的Swift 2和3错误机制与Java / C#/ C ++样式异常之间的主要区别如下:
do-catch
+ try
+ defer
VS传统的try-catch-finally
语法。do-catch
块将不会捕获任何NSException,反之亦然,因为您必须使用ObjC。NSError
返回false
(对于Bool
返回函数)或nil
(对于AnyObject
返回函数)并NSErrorPointer
带有错误详细信息传递的Cocoa 方法约定兼容。作为减轻错误处理的额外语法糖,还有两个概念
defer
关键字),使您可以实现与Java / C#/ etc中的finally块相同的效果guard
关键字),使您编写的if / else代码比普通的错误检查/信号代码少。运行时错误:
正如Leandros建议的那样处理运行时错误(例如网络连接问题,解析数据,打开文件等),您应该NSError
像在ObjC中那样使用,因为Foundation,AppKit,UIKit等以这种方式报告错误。因此,与其说语言,不如说是框架。
正在使用的另一个常见模式是分隔符成功/失败块,例如AFNetworking中:
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")
})
故障块仍然是频繁接收的NSError
实例,描述了错误。
程序员错误:
对于程序员错误(例如对数组元素的越界访问,传递给函数调用的无效参数等),您在ObjC中使用了异常。雨燕语言似乎并未有任何异常的语言支持(如throw
,catch
等关键字)。但是,正如文档所示,它与ObjC在同一运行时上运行,因此您仍然可以这样抛出NSExceptions
:
NSException(name: "SomeName", reason: "SomeReason", userInfo: nil).raise()
尽管您可能选择在ObjC代码中捕获异常,但是您无法在纯Swift中捕获它们。
问题是您是否应该为程序员错误抛出异常,还是应该像苹果在语言指南中建议的那样使用断言。
fatalError(...)
是一样的好。
2015年6月9日更新-非常重要
雨燕2.0配备try
,throw
以及catch
关键字和最令人兴奋的是:
Swift自动将产生错误的Objective-C方法转换为根据Swift的本机错误处理功能抛出错误的方法。
注意:消耗错误的方法(例如委托方法或采用带有NSError对象参数的完成处理程序的方法)不会成为由Swift导入时抛出的方法。
摘自:苹果公司。“将Swift与Cocoa和Objective-C结合使用(Swift 2预发行版)。” iBooks。
示例:(摘自本书)
NSFileManager *fileManager = [NSFileManager defaultManager];
NSURL *URL = [NSURL fileURLWithPath:@"/path/to/file"];
NSError *error = nil;
BOOL success = [fileManager removeItemAtURL:URL error:&error];
if (!success && error){
NSLog(@"Error: %@", error.domain);
}
快速等效为:
let fileManager = NSFileManager.defaultManager()
let URL = NSURL.fileURLWithPath("path/to/file")
do {
try fileManager.removeItemAtURL(URL)
} catch let error as NSError {
print ("Error: \(error.domain)")
}
引发错误:
*errorPtr = [NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorCannotOpenFile userInfo: nil]
将自动传播给调用者:
throw NSError(domain: NSURLErrorDomain, code: NSURLErrorCannotOpenFile, userInfo: nil)
从Apple书籍《 Swift编程语言》看来,应该使用枚举来处理错误。
这是书中的一个例子。
enum ServerResponse {
case Result(String, String)
case Error(String)
}
let success = ServerResponse.Result("6:00 am", "8:09 pm")
let failure = ServerResponse.Error("Out of cheese.")
switch success {
case let .Result(sunrise, sunset):
let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."
case let .Error(error):
let serverResponse = "Failure... \(error)"
}
来自:苹果公司。“快速编程语言”。iBooks。https://itun.es/br/jEUH0.l
更新资料
从Apple新闻书中获得“将Swift与Cocoa和Objective-C结合使用”。使用快速语言不会发生运行时异常,因此这就是为什么您没有try-catch的原因。相反,您使用可选链接。
这是本书的延伸部分:
例如,在下面的代码清单中,第一行和第二行不执行,因为NSDate对象上不存在length属性和characterAtIndex:方法。myLength常数被推断为可选的Int,并且设置为nil。您还可以使用if-let语句有条件地包装对象可能不响应的方法的结果,如第三行所示
let myLength = myObject.length?
let myChar = myObject.characterAtIndex?(5)
if let fifthCharacter = myObject.characterAtIndex(5) {
println("Found \(fifthCharacter) at index 5")
}
摘录自:Apple Inc.“将Swift与Cocoa和Objective-C结合使用。” iBooks。https://itun.es/br/1u3-0.l
并且这些书还鼓励您使用Objective-C(NSError对象)中的可可错误模式
Swift中的错误报告遵循与Objective-C中相同的模式,并具有提供可选返回值的额外好处。在最简单的情况下,您从函数返回一个Bool值以指示其是否成功。当需要报告错误原因时,可以向函数添加NSErrorPointer类型的NSError out参数。此类型与Objective-C的NSError **大致等效,具有额外的内存安全性和可选的类型。您可以使用前缀&运算符将对可选NSError类型的引用作为NSErrorPointer对象传递,如下面的代码清单所示。
var writeError : NSError?
let written = myString.writeToFile(path, atomically: false,
encoding: NSUTF8StringEncoding,
error: &writeError)
if !written {
if let error = writeError {
println("write failure: \(error.localizedDescription)")
}
}
摘录自:Apple Inc.“将Swift与Cocoa和Objective-C结合使用。” iBooks。https://itun.es/br/1u3-0.l
Swift中没有异常,类似于Objective-C的方法。
在开发中,您可以assert
用来捕获可能出现的任何错误,并在生产之前进行修复。
经典NSError
方法没有改变,您发送了NSErrorPointer
,并将其填充。
简要示例:
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)")
}
f();g();
变成f(&err);if(err) return;g(&err);if(err) return;
第一个月,然后就变成了f(nil);g(nil);hopeToGetHereAlive();
推荐的“快速方式”是:
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
}
但是,我更喜欢使用try / catch,因为我发现它更容易理解,因为它会将错误处理最终移到了单独的块中,这种安排有时称为“黄金路径”。幸运的是,您可以使用闭包执行此操作:
TryBool {
write("~/Error2")(error: $0) // The code to try
}.catch {
println("write failure 2: \($0!.localizedDescription)") // Report failure
// assert(false) // Terminate program
}
另外,添加重试工具也很容易:
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
}
TryBool的清单为:
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)
}
}
您可以编写类似的类来测试Optional返回值而不是Bool值:
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)
}
}
TryOptional版本强制使用非可选的返回类型,该类型使后续编程更加容易,例如,“快速方式:
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
使用TryOptional:
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
}
注意自动展开。
编辑:尽管此答案有效,但这仅是音译为Swift的Objective-C。Swift 2.0中的更改已使其过时了。Guilherme Torres Castro的上述回答很好地介绍了Swift中处理错误的首选方法。VOS
需要花点时间才能弄清楚,但我想我很怀疑。虽然看起来很丑。没有比Objective-C版本更薄的皮肤了。
调用带有NSError参数的函数...
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
}`
编写带有错误参数的函数...
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...
}
目标C周围的基本包装器为您提供了try catch功能。 https://github.com/williamFalcon/SwiftTryCatch
使用方式如下:
SwiftTryCatch.try({ () -> Void in
//try something
}, catch: { (error) -> Void in
//handle error
}, finally: { () -> Void in
//close resources
})
这是swift 2.0的更新答案。我期待像Java一样的功能丰富的错误处理模型。最后,他们宣布了好消息。这里
错误处理模型:Swift 2.0中新的错误处理模型将通过熟悉的try,throw和catch关键字立即变得自然。最棒的是,它旨在与Apple SDK和NSError完美配合。实际上,NSError符合Swift的ErrorType。您肯定会希望观看WWDC上有关Swift的新增功能的会议,以了解有关此内容的更多信息。
例如:
func loadData() throws { }
func test() {
do {
try loadData()
} catch {
print(error)
}}
作为吉列尔梅托雷斯卡斯特罗说,在雨燕2.0, ,,try
catch
do
可以在编程中使用。
例如,在CoreData获取数据的方法,而不是放&error
作为参数进入managedContext.executeFetchRequest(fetchRequest, error: &error)
,现在我们只需要使用使用managedContext.executeFetchRequest(fetchRequest)
,然后用处理错误try
,catch
(苹果文档链接)
do {
let fetchedResults = try managedContext.executeFetchRequest(fetchRequest) as? [NSManagedObject]
if let results = fetchedResults{
people = results
}
} catch {
print("Could not fetch")
}
如果您已经下载了xcode7 Beta。尝试在文档和API参考中搜索引发错误然后选择显示的第一个结果,它给出了基本的思路,可以针对这种新语法执行什么操作。但是,关于许多API的完整文档尚未发布。
更多的错误处理技术可以在下面找到
Swift的新功能(2015 Session 106 28m30s)
错误处理是Swift 2.0的新功能。它采用了try
,throw
和catch
关键字。
漂亮且简单的库来处理异常: TryCatchFinally-Swift
像其他一些方法一样,它也包含了目标C异常功能。
像这样使用它:
try {
println(" try")
}.catch { e in
println(" catch")
}.finally {
println(" finally")
}
从Swift 2开始,就像其他人已经提到的那样,错误处理最好通过使用do / try / catch和ErrorType枚举来完成。这对于同步方法非常有效,但是异步错误处理需要一些技巧。
本文对这个问题有一个很好的解决方法:
https://jeremywsherman.com/blog/2015/06/17/using-swift-throws-with-completion-callbacks/
总结一下:
// 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()
}
然后,对上述方法的调用将如下所示:
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
}
})
与将单独的errorHandler回调传递给异步函数相比,这似乎更干净一些,这是在Swift 2之前如何处理的。
我所看到的是,由于设备的性质,您不想向用户抛出一堆神秘的错误处理消息。这就是为什么大多数函数返回可选值,然后您只需编写代码即可忽略可选值的原因。如果函数返回nil表示失败,则可以弹出一条消息或其他任何内容。