blocks|key|131907|text|您必须捕获错误，就像您已经对您的save()调用所做的那样，并且因为您在这里处理多个错误，所以您可以在单个do-+try块中顺序地捕获多个调用，如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|131908|func+deleteAccountDetail()+{
++++let+entityDescription+=+NSEntityDescription.entityForName("AccountDetail",+inManagedObjectContext:+Context!)
++++let+request+=+NSFetchRequest()
++++request.entity+=+entityDescription

++++do+{
++++++++let+fetchedEntities+=+try+self.Context!.executeFetchRequest(request)+as!+[AccountDetail]

++++++++for+entity+in+fetchedEntities+{
++++++++++++self.Context!.deleteObject(entity)
++++++++}

++++++++try+self.Context!.save()
++++}+catch+{
++++++++print(error)
++++}
}|code-block|syntax|javascript|131909|或者就像@bames53在下面的评论中指出的那样，通常更好的做法是不在抛出错误的地方捕捉它。您可以将该方法标记为throws，然后使用try调用该方法。例如：|131910|func+deleteAccountDetail()+throws+{
++++let+entityDescription+=+NSEntityDescription.entityForName("AccountDetail",+inManagedObjectContext:+Context!)
++++let+request+=+NSFetchRequest()

++++request.entity+=+entityDescription

++++let+fetchedEntities+=+try+Context.executeFetchRequest(request)+as!+[AccountDetail]

++++for+entity+in+fetchedEntities+{
++++++++self.Context!.deleteObject(entity)
++++}

++++try+self.Context!.save()
}|131911|entityMap^0|G|6|1L|3|0|0|1K|6|1V|3|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|P|$]]

You have to catch the error just as you're already doing for your <code>save()</code> call and since you're handling multiple errors here, you can <code>try</code> multiple calls sequentially in a single do-catch block, like so:

<pre><code>func deleteAccountDetail() {
 let entityDescription = NSEntityDescription.entityForName("AccountDetail", inManagedObjectContext: Context!)
 let request = NSFetchRequest()
 request.entity = entityDescription

 do {
 let fetchedEntities = try self.Context!.executeFetchRequest(request) as! [AccountDetail]

 for entity in fetchedEntities {
 self.Context!.deleteObject(entity)
 }

 try self.Context!.save()
 } catch {
 print(error)
 }
}
</code></pre>

Or as @bames53 pointed out in the comments below, it is often better practice not to catch the error where it was thrown. You can mark the method as <code>throws</code> then <code>try</code> to call the method. For example:

<pre><code>func deleteAccountDetail() throws {
 let entityDescription = NSEntityDescription.entityForName("AccountDetail", inManagedObjectContext: Context!)
 let request = NSFetchRequest()

 request.entity = entityDescription

 let fetchedEntities = try Context.executeFetchRequest(request) as! [AccountDetail]

 for entity in fetchedEntities {
 self.Context!.deleteObject(entity)
 }

 try self.Context!.save()
}
</code></pre>

blocks|key|133005|text|在Swift中调用使用throws声明的函数时，必须使用try或try!注释函数调用点。例如，给定一个抛出函数：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|133006|func+willOnlyThrowIfTrue(value:+Bool)+throws+{
++if+value+{+throw+someError+}
}|code-block|syntax|javascript|133007|这个函数可以像这样调用：|133008|func+foo(value:+Bool)+throws+{
++try+willOnlyThrowIfTrue(value)
}|133009|在这里，我们使用try对调用进行注释，该调用向读者发出此函数可能抛出异常，并且后面的任何代码行都可能无法执行。我们还必须用throws注释这个函数，因为这个函数可能会抛出异常(即，当willOnlyThrowIfTrue()抛出时，foo会自动向上重新抛出异常。|133010|如果你想调用一个被声明为可能抛出的函数，但你知道在你的情况下不会抛出这个函数，因为你给了它正确的输入，你可以使用try!。|133011|func+bar()+{
++try!+willOnlyThrowIfTrue(false)
}|133012|这样，当您保证代码不会抛出异常时，您就不必放入额外的样板代码来禁用异常传播。|133013|try!是在运行时强制执行的:如果您使用try!，并且函数确实抛出了异常，那么您的程序的执行将因运行时错误而终止。|133014|大多数异常处理代码应该类似于上面的代码:要么在异常发生时简单地向上传播异常，要么设置条件以排除其他可能的异常。对代码中其他资源的任何清理都应该通过对象销毁(即deinit())进行，有时也可以通过defered代码进行。|133015|func+baz(value:+Bool)+throws+{

++var+filePath+=+NSBundle.mainBundle().pathForResource("theFile",+ofType:"txt")
++var+data+=+NSData(contentsOfFile:filePath)

++try+willOnlyThrowIfTrue(value)

++//+data+and+filePath+automatically+cleaned+up,+even+when+an+exception+occurs.
}|133016|如果出于某种原因，您清理了需要运行但不在deinit()函数中的代码，您可以使用defer。|133017|func+qux(value:+Bool)+throws+{
++defer+{
++++print("this+code+runs+when+the+function+exits,+even+when+it+exits+by+an+exception")
++}

++try+willOnlyThrowIfTrue(value)
}|133018|133019|大多数处理异常的代码只是让它们向上传播到调用者，通过deinit()或defer在过程中进行清理。这是因为大多数代码不知道如何处理错误；它知道哪里出了问题，但它没有足够的信息来了解一些更高级别的代码正在尝试做什么，以便知道如何处理错误。它不知道向用户呈现对话框是否合适，或者是否应该重试，或者其他东西是否合适。|133020|然而，更高级别的代码应该确切地知道在发生任何错误时该如何处理。因此，异常允许特定的错误从最初发生的地方到可以处理的地方冒泡。|133021|异常处理是通过catch语句完成的。|133022|func+quux(value:+Bool)+{
++do+{
++++try+willOnlyThrowIfTrue(value)
++}+catch+{
++++//+handle+error
++}
}|133023|可以有多个catch语句，每个语句捕获一种不同类型的异常。|133024|++do+{
++++try+someFunctionThatThowsDifferentExceptions()
++}+catch+MyErrorType.errorA+{
++++//+handle+errorA
++}+catch+MyErrorType.errorB+{
++++//+handle+errorB
++}+catch+{
++++//+handle+other+errors
++}|133025|133026|有关处理异常的最佳实践的更多详细信息，请参阅http://exceptionsafecode.com/。它是专门针对C%2B%2B的，但在研究了Swift异常模型之后，我相信基本原理也适用于Swift。|133027|有关Swift语法和错误处理模型的详细信息，请参阅一书。|133028|entityMap|0|LINK|mutability|MUTABLE|url|http://exceptionsafecode.com/^0|B|6|S|3|W|4|0|0|0|0|8|3|1P|6|2J|L|38|3|0|1K|4|0|0|0|0|4|K|4|0|27|8|2Q|5|0|0|K|8|14|5|0|0|0|Q|8|Z|5|0|0|7|5|0|0|0|0|0|M|T|0|0|0^^$0|@$1|2|3|4|5|6|7|1W|8|@$9|1X|A|1Y|B|C]|$9|1Z|A|20|B|C]|$9|21|A|22|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|23|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|24|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|25|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|26|8|@$9|27|A|28|B|C]|$9|29|A|2A|B|C]|$9|2B|A|2C|B|C]|$9|2D|A|2E|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|2F|8|@$9|2G|A|2H|B|C]]|D|@]|E|$]]|$1|S|3|T|5|H|7|2I|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|2J|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|2K|8|@$9|2L|A|2M|B|C]|$9|2N|A|2O|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|2P|8|@$9|2Q|A|2R|B|C]|$9|2S|A|2T|B|C]]|D|@]|E|$]]|$1|10|3|11|5|H|7|2U|8|@]|D|@]|E|$I|J]]|$1|12|3|13|5|6|7|2V|8|@$9|2W|A|2X|B|C]|$9|2Y|A|2Z|B|C]]|D|@]|E|$]]|$1|14|3|15|5|H|7|30|8|@]|D|@]|E|$I|J]]|$1|16|3|-4|5|6|7|31|8|@]|D|@]|E|$]]|$1|17|3|18|5|6|7|32|8|@$9|33|A|34|B|C]|$9|35|A|36|B|C]]|D|@]|E|$]]|$1|19|3|1A|5|6|7|37|8|@]|D|@]|E|$]]|$1|1B|3|1C|5|6|7|38|8|@$9|39|A|3A|B|C]]|D|@]|E|$]]|$1|1D|3|1E|5|H|7|3B|8|@]|D|@]|E|$I|J]]|$1|1F|3|1G|5|6|7|3C|8|@]|D|@]|E|$]]|$1|1H|3|1I|5|H|7|3D|8|@]|D|@]|E|$I|J]]|$1|1J|3|-4|5|6|7|3E|8|@]|D|@]|E|$]]|$1|1K|3|1L|5|6|7|3F|8|@]|D|@$9|3G|A|3H|1|3I]]|E|$]]|$1|1M|3|1N|5|6|7|3J|8|@]|D|@]|E|$]]|$1|1O|3|-4|5|6|7|3K|8|@]|D|@]|E|$]]]|1P|$1Q|$5|1R|1S|1T|E|$1U|1V]]]]

When calling a function that is declared with <code>throws</code> in Swift, you must annotate the function call site with <code>try</code> or <code>try!</code>. For example, given a throwing function:

<pre><code>func willOnlyThrowIfTrue(value: Bool) throws {
 if value { throw someError }
}
</code></pre>

this function can be called like:

<pre><code>func foo(value: Bool) throws {
 try willOnlyThrowIfTrue(value)
}
</code></pre>

Here we annotate the call with <code>try</code>, which calls out to the reader that this function may throw an exception, and any following lines of code might not be executed. We also have to annotate this function with <code>throws</code>, because this function could throw an exception (i.e., when <code>willOnlyThrowIfTrue()</code> throws, then <code>foo</code> will automatically rethrow the exception upwards.

If you want to call a function that is declared as possibly throwing, but which you know will not throw in your case because you're giving it correct input, you can use <code>try!</code>.

<pre><code>func bar() {
 try! willOnlyThrowIfTrue(false)
}
</code></pre>

This way, when you guarantee that code won't throw, you don't have to put in extra boilerplate code to disable exception propagation.

<code>try!</code> is enforced at runtime: if you use <code>try!</code> and the function does end up throwing, then your program's execution will be terminated with a runtime error.

Most exception handling code should look like the above: either you simply propagate exceptions upward when they occur, or you set up conditions such that otherwise possible exceptions are ruled out. Any clean up of other resources in your code should occur via object destruction (i.e. <code>deinit()</code>), or sometimes via <code>defer</code>ed code.

<pre><code>func baz(value: Bool) throws {

 var filePath = NSBundle.mainBundle().pathForResource("theFile", ofType:"txt")
 var data = NSData(contentsOfFile:filePath)

 try willOnlyThrowIfTrue(value)

 // data and filePath automatically cleaned up, even when an exception occurs.
}
</code></pre>

If for whatever reason you have clean up code that needs to run but isn't in a <code>deinit()</code> function, you can use <code>defer</code>.

<pre><code>func qux(value: Bool) throws {
 defer {
 print("this code runs when the function exits, even when it exits by an exception")
 }

 try willOnlyThrowIfTrue(value)
}
</code></pre>

<hr>

Most code that deals with exceptions simply has them propagate upward to callers, doing cleanup on the way via <code>deinit()</code> or <code>defer</code>. This is because most code doesn't know what to do with errors; it knows what went wrong, but it doesn't have enough information about what some higher level code is trying to do in order to know what to do about the error. It doesn't know if presenting a dialog to the user is appropriate, or if it should retry, or if something else is appropriate.

Higher level code, however, should know exactly what to do in the event of any error. So exceptions allow specific errors to bubble up from where they initially occur to the where they can be handled.

Handling exceptions is done via <code>catch</code> statements.

<pre><code>func quux(value: Bool) {
 do {
 try willOnlyThrowIfTrue(value)
 } catch {
 // handle error
 }
}
</code></pre>

You can have multiple catch statements, each catching a different kind of exception.

<pre><code> do {
 try someFunctionThatThowsDifferentExceptions()
 } catch MyErrorType.errorA {
 // handle errorA
 } catch MyErrorType.errorB {
 // handle errorB
 } catch {
 // handle other errors
 }
</code></pre>

<hr>

For more details on best practices with exceptions, see <a href="http://exceptionsafecode.com/" rel="noreferrer">http://exceptionsafecode.com/</a>. It's specifically aimed at C++, but after examining the Swift exception model, I believe the basics apply to Swift as well.

For details on the Swift syntax and error handling model, see the book <a href="https://itunes.apple.com/us/book/swift-programming-language/id1002622538?mt=11" rel="noreferrer">The Swift Programming Language (Swift 2 Prerelease)</a>.

After I installed Xcode 7 beta and convert my swift code to Swift 2, I got some issue with the code that I can't figure out. I know Swift 2 is new so I search and figure out since there is nothing about it, I should write a question.

Here is the error:

<blockquote>
 Call can throw, but it is not marked with 'try' and the error is not
 handled
</blockquote>

Code:

<pre><code>func deleteAccountDetail(){
 let entityDescription = NSEntityDescription.entityForName("AccountDetail", inManagedObjectContext: Context!)
 let request = NSFetchRequest()
 request.entity = entityDescription

 //The Line Below is where i expect the error
 let fetchedEntities = self.Context!.executeFetchRequest(request) as! [AccountDetail]

 for entity in fetchedEntities {
 self.Context!.deleteObject(entity)
 }

 do {
 try self.Context!.save()
 } catch _ {
 }

 }
</code></pre>

Snapshot: 
<img src="https://i.stack.imgur.com/GVdm3.png" alt="enter image description here">

Swift 2: Call can throw, but it is not marked with 'try' and the error is not handled

Swift

在我安装了Xcode7测试版并将我的swift代码转换为Swift 2之后，我遇到了一些我无法解决的代码问题。我知道Swift 2是新的，所以我搜索并计算出，既然没有关于它的任何东西，我应该写一个问题。这里是错误：调用可以引发，但未标记为“try”，并且未处理错误代码：func deleteAccountDetail(...

问Swift 2:调用可以抛出，但未标记为“try”，并且未处理错误
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Swift 2:调用可以抛出，但未标记为“try”，并且未处理错误EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Swift 2:调用可以抛出，但未标记为“try”，并且未处理错误
EN