From 59c3762fc255661d3cde45763e322f869678e11f Mon Sep 17 00:00:00 2001 From: Shindo Date: Mon, 9 Jun 2014 15:24:06 +0800 Subject: [PATCH 1/5] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E4=B8=80=E4=BA=9B?= =?UTF-8?q?=E8=A1=A8=E8=BE=BE=E6=96=B9=E5=BC=8F=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/chapter3/10_Statements.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/chapter3/10_Statements.md b/source/chapter3/10_Statements.md index 34e15e13..f372454e 100644 --- a/source/chapter3/10_Statements.md +++ b/source/chapter3/10_Statements.md @@ -372,4 +372,4 @@ return `表达式` > GRAMMAR OF A RETURN STATEMENT -> *return-statement* → **return** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) *opt* \ No newline at end of file +> *return-statement* → **return** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) *opt* From e075ce6bca9d823495ac054ee78c1886774635fd Mon Sep 17 00:00:00 2001 From: Shindo Date: Mon, 9 Jun 2014 19:11:20 +0800 Subject: [PATCH 2/5] =?UTF-8?q?=E5=8D=A0=E5=9D=91=20Control=20Flow:=20Cond?= =?UTF-8?q?itional=20Statements?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/chapter2/05_Control_Flow.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/chapter2/05_Control_Flow.md b/source/chapter2/05_Control_Flow.md index 5ad51630..7c8bef33 100644 --- a/source/chapter2/05_Control_Flow.md +++ b/source/chapter2/05_Control_Flow.md @@ -1,3 +1,3 @@ # 控制流 -Swift提供了类似C语言的流程控制结构，包括将任务执行多次的`for`和`while`循环，基于特定条件选择执行不同分支的`if`和`switch`语句，还有控制流程跳转到其他代码的`break`和`continue`语句。 \ No newline at end of file +## 条件语句 \ No newline at end of file From c2ebe506ed42a1e3b0d164660b43dfae460ae2fa Mon Sep 17 00:00:00 2001 From: Shindo Date: Mon, 9 Jun 2014 23:30:07 +0800 Subject: [PATCH 3/5] =?UTF-8?q?=E7=BB=9F=E4=B8=80=E7=AC=A6=E5=8F=B7?= =?UTF-8?q?=E4=BD=BF=E7=94=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/chapter3/10_Statements.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source/chapter3/10_Statements.md b/source/chapter3/10_Statements.md index f372454e..4fe3d7a9 100644 --- a/source/chapter3/10_Statements.md +++ b/source/chapter3/10_Statements.md @@ -243,7 +243,7 @@ case let (x, y) where x == y: #### Switch 语句必须是完备的 -在 Swift 中，`switch`语句中控制表达式的每一个可能的值都必须至少有一个`case`块与之对应。在某些情况下（例如，表达式的类型是`Int`），你可以使用默认块满足该要求。 +在 Swift 中，`switch`语句中控制表达式的每一个可能的值都必须至少有一个*case*块与之对应。在某些情况下（例如，表达式的类型是`Int`），你可以使用默认块满足该要求。 #### 不存在隐式的贯穿(fall through) @@ -345,9 +345,9 @@ continue `label name` ### Fallthrough 语句 -`fallthrough`语句用于在`switch`语句中传递控制权。`fallthrough`语句会把控制权从`switch`语句中的一个`case`传递给下一个`case`。这种传递是无条件的，即使下一个`case`的值与`switch`语句的控制表达式的值不匹配。 +`fallthrough`语句用于在`switch`语句中传递控制权。`fallthrough`语句会把控制权从`switch`语句中的一个*case*传递给下一个*case*。这种传递是无条件的，即使下一个*case*的值与`switch`语句的控制表达式的值不匹配。 -`fallthrough`语句可出现在`switch`语句中的任意`case`里，但不能出现在最后一个'case'块。同时，`fallthrough`语句也不能把控制权传递给使用了可选绑定的`case`块。 +`fallthrough`语句可出现在`switch`语句中的任意*case*里，但不能出现在最后一个*case*块中。同时，`fallthrough`语句也不能把控制权传递给使用了可选绑定的*case*块。 关于在`switch`语句中使用`fallthrough`语句的例子，请参考[控制流`待添加链接`]()一章的[控制传递语句`待添加链接`]()。 From db6cfda6591105d4dcd5aecb4e6d7ffb6f6bdae9 Mon Sep 17 00:00:00 2001 From: Shindo Date: Tue, 10 Jun 2014 00:10:45 +0800 Subject: [PATCH 4/5] =?UTF-8?q?=E5=AE=8C=E6=88=90Conditional=20Statements?= =?UTF-8?q?=E7=9A=84=E7=BF=BB=E8=AF=91=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/chapter2/05_Control_Flow.md | 256 ++++++++++++++++++++++++++++- 1 file changed, 255 insertions(+), 1 deletion(-) diff --git a/source/chapter2/05_Control_Flow.md b/source/chapter2/05_Control_Flow.md index 7c8bef33..f645a63e 100644 --- a/source/chapter2/05_Control_Flow.md +++ b/source/chapter2/05_Control_Flow.md @@ -1,3 +1,257 @@ # 控制流 -## 条件语句 \ No newline at end of file +## 条件语句 + +根据特定的条件执行特定的代码通常是十分有用的，例如：当错误发生时，你可能想运行额外的代码；或者，当输入的值太大或太小时，向用户显示一条消息等。要实现这些功能，你就需要使用*条件语句*。 + +Swift 提供两种类型的条件语句：`if`语句和`switch`语句。通常，当条件较为简单且可能的情况很少时，使用`if`语句。而`switch`语句更适用于复杂的条件、可能的情况很多且需要用到模式匹配(pattern-matching)的情境。 + +### If + +`if`语句最简单的形式就是只包含一个条件，当且仅当该条件为`真`时，才执行相关代码： + +```swift +var temperatureInFahrenheit = 30 +if temperatureInFahrenheit <= 32 { + println("It's very cold. Consider wearing a scarf.") +} +// prints "It's very cold. Consider wearing a scarf." +``` + +上面的例子会判断温度是否小于等于32华氏度（水的冰点）。如果是，则打印一条消息；否则，不打印任何消息，继续执行`if`块后面的代码。 + +当然，`if`语句允许二选一，也就是当条件为假时，执行*else语句*： + +```swift +temperatureInFahrenheit = 40 +if temperatureInFahrenheit <= 32 { + println("It's very cold. Consider wearing a scarf.") +} else { + println("It's not that cold. Wear a t-shirt.") +} +// prints "It's not that cold. Wear a t-shirt." +``` + +显然，这两条分支中总有一条会被执行。由于温度已升至40华氏度，不算太冷，没必要再围围巾——因此，`else`分支就被触发了。 + +你可以把多个`if`语句链接在一起，像下面这样： + +```swift +temperatureInFahrenheit = 90 +if temperatureInFahrenheit <= 32 { + println("It's very cold. Consider wearing a scarf.") +} else if temperatureInFahrenheit >= 86 { + println("It's really warm. Don't forget to wear sunscreen.") +} else { + println("It's not that cold. Wear a t-shirt.") +} +// prints "It's really warm. Don't forget to wear sunscreen." +``` + +在上面的例子中，额外的`if`语句用于判断是不是特别热。而最后的*else语句*被保留了下来，用于打印既不冷也不热时的消息。 + +实际上，最后的*else语句*是可选的： + +```swift +temperatureInFahrenheit = 72 +if temperatureInFahrenheit <= 32 { + println("It's very cold. Consider wearing a scarf.") +} else if temperatureInFahrenheit >= 86 { + println("It's really warm. Don't forget to wear sunscreen.") +} +``` + +在这个例子中，由于既不冷也不热，所以不会触发`if`或`else if`分支，也就不会打印任何消息。 + +### Switch + +`switch`语句会尝试把某个值与若干个模式(pattern)进行匹配。根据第一个匹配成功的模式，`switch`语句会执行对应的代码。当有可能的情况较多时，通常用`switch`语句替换`if`语句。 + +`switch`语句最简单的形式就是把某个值与一个或若干个相同类型的值作比较： + +```swift +switch `some value to consider` { +case `value 1`: + `respond to value 1` +case `value 2`, +`value 3`: + `respond to value 2 or 3` +default: + `otherwise, do something else` +} +``` + +`switch`语句都由多个*case*构成。为了匹配某些更特定的值，Swift 提供了几种更复杂的匹配模式，这些模式将在本节的稍后部分提到。 + +每一个*case*都是代码执行的一条分支，这与`if`语句类似。与之不同的是，`switch`语句会决定哪一条分支应该被执行。 + +`switch`语句必须是完备的。这就是说，每一个可能的值都必须至少有一个*case*块与之对应。在某些不可能涵盖所有值的情况下，你可以使用默认(`default`)块满足该要求，这个默认块必须在`switch`语句的最后面。 + +下面的例子使用`switch`语句来匹配一个名为`someCharacter`的小写字符： + +```swift +let someCharacter: Character = "e" +switch someCharacter { +case "a", "e", "i", "o", "u": + println("\(someCharacter) is a vowel") +case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m", +"n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z": + println("\(someCharacter) is a consonant") +default: + println("\(someCharacter) is not a vowel or a consonant") +} +// prints "e is a vowel" +``` + +在这个例子中，第一个*case*块用于匹配五个元音，第二个*case*块用于匹配所有的辅音。 + +由于为其它可能的字符写*case*快没有实际的意义，因此在这个例子中使用了默认块来处理剩下的既不是元音也不是辅音的字符——这就保证了`switch`语句的完备性。 + +#### 不存在隐式的贯穿(Fallthrough) + +与C语言和Objective-C中的`switch`语句不同，在 Swift 中，当匹配的*case*块中的代码执行完毕后，程序会终止`switch`语句，而不会继续执行下一个*case*块。这也就是说，不需要在*case*块中显式地使用`break`语句。这使得`switch`语句更安全、更易用，也避免了因忘记写`break`语句而产生的错误。 + +> 注意：你依然可以在*case*块中的代码执行完毕前跳出，详情请参考[Switch 语句中的 Break`待添加链接`]() + +每一个*case*块都*必须*包含至少一条语句。像下面这样书写代码是无效的，因为第一个*case*块是空的： + +```swift +let anotherCharacter: Character = "a" +switch anotherCharacter { +case "a": +case "A": + println("The letter A") +default: + println("Not the letter A") +} +// this will report a compile-time error +``` + +不像C语言里的`switch`语句，在 Swift 中，`switch`语句不会同时匹配`"a"`和`"A"`。相反的，上面的代码会引起编译期错误：`case "a": does not contain any executable statements`——这就避免了意外地从一个*case*块贯穿到另外一个，使得代码更安全、也更直观。 + +一个*case*也可以包含多个模式，用逗号把它们分开（如果太长了也可以分行写）： + +```swift +switch `some value to consider` { +case `value 1`, +`value 2`: + `statements` +} +``` + +> 注意：如果想要贯穿特定的*case*块中，请使用`fallthrough`语句，详情请参考[贯穿 (Fallthrough)`待添加链接`]() + +#### 范围匹配 + +*case*块的模式也可以是一个值的范围。下面的例子展示了如何使用范围匹配来输出任意数字对应的自然语言格式： + +```swift +let count = 3_000_000_000_000 +let countedThings = "stars in the Milky Way" +var naturalCount: String +switch count { +case 0: + naturalCount = "no" +case 1...3: + naturalCount = "a few" +case 4...9: + naturalCount = "several" +case 10...99: + naturalCount = "tens of" +case 100...999: + naturalCount = "hundreds of" +case 1000...999_999: + naturalCount = "thousands of" +default: + naturalCount = "millions and millions of" +} +println("There are \(naturalCount) \(countedThings).") +// prints "There are millions and millions of stars in the Milky Way." +``` + +#### 元组 (Tuple) + +你可以使用元组在同一个`switch`语句中测试多个值。元组中的元素可以是值，也可以是范围。另外，使用下划线(_)来匹配所有可能的值。 + +下面的例子展示了如何使用一个`(Int, Int)`类型的元组来分类下图中的点(x, y)： + +```swift +let somePoint = (1, 1) +switch somePoint { +case (0, 0): + println("(0, 0) is at the origin") +case (_, 0): + println("(\(somePoint.0), 0) is on the x-axis") +case (0, _): + println("(0, \(somePoint.1)) is on the y-axis") +case (-2...2, -2...2): + println("(\(somePoint.0), \(somePoint.1)) is inside the box") +default: + println("(\(somePoint.0), \(somePoint.1)) is outside of the box") +} +// prints "(1, 1) is inside the box" +``` + + + +在上面的例子中，`switch`语句会判断某个点是否是原点(0, 0)，是否在红色的x轴上，是否在黄色y轴上，是否在一个以原点为中心的4x4的矩形里，或者在这个矩形外面。 + +不像C语言，Swift 允许多个*case*匹配同一个值。实际上，在这个例子中，点(0, 0)可以匹配所有*四个case*。但是，如果存在多个匹配，那么只会执行第一个被匹配到的*case*块。考虑点(0, 0)会首先匹配`case (0, 0)`，因此剩下的能够匹配(0, 0)的*case*块都会被忽视掉。 + +#### 值绑定 (Value Bindings) + +*case*块的模式允许将匹配的值绑定到一个临时的常量或变量，这些常量或变量在该*case*块里就可以被引用了——这种行为被称为*值绑定*。 + +下面的例子展示了如何在一个`(Int, Int)`类型的元组中使用值绑定来分类下图中的点(x, y)： + +```swift +let anotherPoint = (2, 0) +switch anotherPoint { +case (let x, 0): + println("on the x-axis with an x value of \(x)") +case (0, let y): + println("on the y-axis with a y value of \(y)") +case let (x, y): + println("somewhere else at (\(x), \(y))") +} +// prints "on the x-axis with an x value of 2" +``` + + + +在上面的例子中，`switch`语句会判断某个点是否在红色的x轴上，是否在黄色y轴上，或者不在坐标轴上。 + +这三个*case*都声明了常量`x`和`y`的占位符，用于临时获取元组`anotherPoint`的一个或两个值。第一个*case*——`case (let x, 0)`将匹配一个纵坐标为`0`的点，并把这个点的横坐标赋给临时的常量`x`。类似的，第二个*case*——`case (0, let y)`将匹配一个横坐标为`0`的点，并把这个点的纵坐标赋给临时的常量`y`。 + +一旦声明了这些临时的常量，它们就可以在其对应的*case*块里引用。在这个例子中，它们用于简化`println`的书写。 + +请注意，这个`switch`语句不包含默认块。这是因为最后一个*case*——`case let(x, y)`声明了一个可以匹配余下所有值的元组。这使得`switch`语句已经完备了，因此不需要再书写默认块。 + +在上面的例子中，`x`和`y`是常量，这是因为没有必要在其对应的*case*块中修改它们的值。然而，它们也可以是变量——程序将会创建临时变量，并用相应的值初始化它。修改这些变量只会影响其对应的*case*块。 + +#### Where + +*case*块的模式可以使用`where`语句来判断额外的条件。 + +下面的例子把下图中的点(x, y)进行了分类： + +```swift +let yetAnotherPoint = (1, -1) +switch yetAnotherPoint { +case let (x, y) where x == y: + println("(\(x), \(y)) is on the line x == y") +case let (x, y) where x == -y: + println("(\(x), \(y)) is on the line x == -y") +case let (x, y): + println("(\(x), \(y)) is just some arbitrary point") +} +// prints "(1, -1) is on the line x == -y" +``` + + + +在上面的例子中，`switch`语句会判断某个点是否在绿色的对角线`x == y`上，是否在紫色的对角线'x == -y'上，或者不在对角线上。 + +这三个*case*都声明了常量`x`和`y`的占位符，用于临时获取元组`yetAnotherPoint`的两个值。这些常量被用作`where`语句的一部分，从而创建一个动态的过滤器(filter)。当且仅当`where`语句的条件为`真`时，匹配到的*case*块才会被执行。 + +就像是值绑定中的例子，由于最后一个*case*块匹配了余下所有可能的值，`switch`语句就已经完备了，因此不需要再书写默认块。 \ No newline at end of file From 6deeee04d50bb52ced25f64c4676f90c7e7c5b1e Mon Sep 17 00:00:00 2001 From: Shindo Date: Tue, 10 Jun 2014 12:48:57 +0800 Subject: [PATCH 5/5] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E4=B8=80=E4=BA=9B?= =?UTF-8?q?=E9=94=9A=E8=AE=B0=E5=92=8C=E9=93=BE=E6=8E=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/chapter2/05_Control_Flow.md | 5 ++++- source/chapter3/10_Statements.md | 23 +++++++++++++---------- 2 files changed, 17 insertions(+), 11 deletions(-) diff --git a/source/chapter2/05_Control_Flow.md b/source/chapter2/05_Control_Flow.md index f645a63e..f9eeb563 100644 --- a/source/chapter2/05_Control_Flow.md +++ b/source/chapter2/05_Control_Flow.md @@ -1,11 +1,13 @@ # 控制流 + ## 条件语句 根据特定的条件执行特定的代码通常是十分有用的，例如：当错误发生时，你可能想运行额外的代码；或者，当输入的值太大或太小时，向用户显示一条消息等。要实现这些功能，你就需要使用*条件语句*。 Swift 提供两种类型的条件语句：`if`语句和`switch`语句。通常，当条件较为简单且可能的情况很少时，使用`if`语句。而`switch`语句更适用于复杂的条件、可能的情况很多且需要用到模式匹配(pattern-matching)的情境。 + ### If `if`语句最简单的形式就是只包含一个条件，当且仅当该条件为`真`时，才执行相关代码： @@ -63,6 +65,7 @@ if temperatureInFahrenheit <= 32 { 在这个例子中，由于既不冷也不热，所以不会触发`if`或`else if`分支，也就不会打印任何消息。 + ### Switch `switch`语句会尝试把某个值与若干个模式(pattern)进行匹配。根据第一个匹配成功的模式，`switch`语句会执行对应的代码。当有可能的情况较多时，通常用`switch`语句替换`if`语句。 @@ -250,7 +253,7 @@ case let (x, y): -在上面的例子中，`switch`语句会判断某个点是否在绿色的对角线`x == y`上，是否在紫色的对角线'x == -y'上，或者不在对角线上。 +在上面的例子中，`switch`语句会判断某个点是否在绿色的对角线`x == y`上，是否在紫色的对角线`x == -y`上，或者不在对角线上。 这三个*case*都声明了常量`x`和`y`的占位符，用于临时获取元组`yetAnotherPoint`的两个值。这些常量被用作`where`语句的一部分，从而创建一个动态的过滤器(filter)。当且仅当`where`语句的条件为`真`时，匹配到的*case*块才会被执行。 diff --git a/source/chapter3/10_Statements.md b/source/chapter3/10_Statements.md index 4fe3d7a9..3206fbf7 100644 --- a/source/chapter3/10_Statements.md +++ b/source/chapter3/10_Statements.md @@ -26,7 +26,7 @@ 取决于特定的循环条件，循环语句允许重复执行代码块。Swift 提供四种类型的循环语句：`for`语句、`for-in`语句、`while`语句和`do-while`语句。 -通过`break`语句和`continue`语句可以改变循环语句的控制流。有关这两条语句，请参考[*Break 语句*`待添加链接`]()和[*Continue 语句*`待添加链接`]()。 +通过`break`语句和`continue`语句可以改变循环语句的控制流。有关这两条语句，请参考[Break 语句](#break_statement)和[Continue 语句](#continue_statement)。 > GRAMMAR OF A LOOP STATEMENT @@ -149,7 +149,7 @@ do { 取决于一个或者多个条件的值，分支语句允许程序执行指定部分的代码。显然，分支语句中条件的值将会决定如何分支以及执行哪一块代码。Swift 提供两种类型的分支语句：`if`语句和`switch`语句。 -`switch`语句中的控制流可以用`break`语句修改，请参考[Break 语句`待添加链接`]()。 +`switch`语句中的控制流可以用`break`语句修改，请参考[Break 语句](#break_statement)。 > GRAMMAR OF A BRANCH STATEMENT @@ -226,7 +226,7 @@ switch `control expression` { `switch`语句的*控制表达式(control expression)*会首先被计算，然后与每一个*case*的模式(pattern)进行匹配。如果匹配成功，程序将会执行对应的*case*块里的*statements*。另外，每一个*case*块都不能为空，也就是说在每一个*case*块中至少有一条语句。如果你不想在匹配到的*case*块中执行代码，只需在块里写一条`break`语句即可。 -可以用作控制表达式的值是十分灵活的，除了标量类型(scalar types，如`Int`、`Character`)外，你可以使用任何类型的值，包括浮点数、字符串、元组、自定义类的实例和可选(optional)类型，甚至是枚举类型中的成员值和指定的范围(range)等。关于在`switch`语句中使用这些类型，请参考[控制流`待添加链接`]()一章的[Switch`待添加链接`]()。 +可以用作控制表达式的值是十分灵活的，除了标量类型(scalar types，如`Int`、`Character`)外，你可以使用任何类型的值，包括浮点数、字符串、元组、自定义类的实例和可选(optional)类型，甚至是枚举类型中的成员值和指定的范围(range)等。关于在`switch`语句中使用这些类型，请参考[控制流](../chapter2/05_Control_Flow.html)一章的[Switch](../chapter2/05_Control_Flow.html#switch)。 你可以在模式后面添加一个起保护作用的表达式(guard expression)。*起保护作用的表达式*是这样构成的：关键字`where`后面跟着一个作为额外测试条件的表达式。因此，当且仅当*控制表达式*匹配一个*case*的某个模式且起保护作用的表达式为真时，对应*case*块中的*statements*才会被执行。在下面的例子中，*控制表达式*只会匹配含两个相等元素的元组，如`(1, 1)`： @@ -247,7 +247,7 @@ case let (x, y) where x == y: #### 不存在隐式的贯穿(fall through) -当匹配的*case*块中的代码执行完毕后，程序会终止`switch`语句，而不会继续执行下一个*case*块。这就意味着，如果你想执行下一个*case*块，需要显式地在你需要的*case*块里使用`fallthrough`语句。关于`fallthrough`语句的更多信息，请参考[Fallthrough 语句`待添加链接`]()。 +当匹配的*case*块中的代码执行完毕后，程序会终止`switch`语句，而不会继续执行下一个*case*块。这就意味着，如果你想执行下一个*case*块，需要显式地在你需要的*case*块里使用`fallthrough`语句。关于`fallthrough`语句的更多信息，请参考[Fallthrough 语句](#fallthrough_statement)。 > GRAMMAR OF A SWITCH STATEMENT @@ -271,11 +271,11 @@ case let (x, y) where x == y: ## 带标签的语句 -你可以在循环语句或`switch`语句前面加上*标签*，它由标签名和紧随其后的冒号(:)组成。在`break`和`continue`后面跟上标签名可以显式地在循环语句或`switch`语句中更改控制流，把控制权传递给指定标签标记的语句。关于这两条语句用法，请参考[Break 语句`待添加链接`]()和[Continue 语句`待添加链接`]()。 +你可以在循环语句或`switch`语句前面加上*标签*，它由标签名和紧随其后的冒号(:)组成。在`break`和`continue`后面跟上标签名可以显式地在循环语句或`switch`语句中更改控制流，把控制权传递给指定标签标记的语句。关于这两条语句用法，请参考[Break 语句](#break_statement)和[Continue 语句](#continue_statement)。 标签的作用域是该标签所标记的语句之后的所有语句。你可以不使用带标签的语句，但只要使用它，标签名就必唯一。 -关于使用带标签的语句的例子，请参考[控制流`待添加链接`]()一章的[带标签的语句`待添加链接`]()。 +关于使用带标签的语句的例子，请参考[控制流](../chapter2/05_Control_Flow.html)一章的[带标签的语句`待添加链接`]()。 > GRAMMAR OF A LABELED STATEMENT @@ -299,6 +299,7 @@ case let (x, y) where x == y: > *control-transfer-statement* → [*return-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/return-statement) + ### Break 语句 `break`语句用于终止循环或`switch`语句的执行。使用`break`语句时，可以只写`break`这个关键词，也可以在`break`后面跟上标签名(label name)，像下面这样： @@ -314,12 +315,13 @@ break `label name` 在这两种情况下，控制权都会被传递给循环或`switch`语句外面的第一行语句。 -关于使用`break`语句的例子，请参考[控制流`待添加链接`]()一章的[Break`待添加链接`]()和[带标签的语句`待添加链接`]()。 +关于使用`break`语句的例子，请参考[控制流](../chapter2/05_Control_Flow.html)一章的[Break`待添加链接`]()和[带标签的语句`待添加链接`]()。 > GRAMMAR OF A BREAK STATEMENT > *break-statement* → **break** [*label-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/label-name) *opt* + ### Continue 语句 `continue`语句用于终止循环中当前迭代的执行，但不会终止该循环的执行。使用`continue`语句时，可以只写`continue`这个关键词，也可以在`continue`后面跟上标签名(label name)，像下面这样： @@ -337,21 +339,22 @@ continue `label name` 在`for`语句中，`continue`语句执行后，*increment*表达式还是会被计算，这是因为每次循环体执行完毕后*increment*表达式都会被计算。 -关于使用`continue`语句的例子，请参考[控制流`待添加链接`]()一章的[Continue`待添加链接`]()和[带标签的语句`待添加链接`]()。 +关于使用`continue`语句的例子，请参考[控制流](../chapter2/05_Control_Flow.html)一章的[Continue`待添加链接`]()和[带标签的语句`待添加链接`]()。 > GRAMMAR OF A CONTINUE STATEMENT > *continue-statement* → **continue** [*label-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/label-name) *opt* + ### Fallthrough 语句 `fallthrough`语句用于在`switch`语句中传递控制权。`fallthrough`语句会把控制权从`switch`语句中的一个*case*传递给下一个*case*。这种传递是无条件的，即使下一个*case*的值与`switch`语句的控制表达式的值不匹配。 `fallthrough`语句可出现在`switch`语句中的任意*case*里，但不能出现在最后一个*case*块中。同时，`fallthrough`语句也不能把控制权传递给使用了可选绑定的*case*块。 -关于在`switch`语句中使用`fallthrough`语句的例子，请参考[控制流`待添加链接`]()一章的[控制传递语句`待添加链接`]()。 +关于在`switch`语句中使用`fallthrough`语句的例子，请参考[控制流](../chapter2/05_Control_Flow.html)一章的[控制传递语句`待添加链接`]()。 -> GRAMMAR OF A FALLTRHOUGH STATEMENT +> GRAMMAR OF A FALLTHROUGH STATEMENT > *continue-statement* → **fallthrough**