Swift 是一种新的编程语言，用于编写 iOS 和 OS X 应用程序。Swift 结合了 C 和 Objective-C 的优点并且不受C的兼容性的限制。Swift 使用安全的编程模式并添加了很多新特性，这将使编程更简单，扩展性更强，也更有趣。除此之外，Swift 还支持人见人爱的 Cocoa 和 Cocoa Touch 框架。拥有了这些特性，Swift将重新定义软件开发。
diff --git a/chapter1/02_a_swift_tour.html b/chapter1/02_a_swift_tour.html index c9715200..4e2e5936 100644 --- a/chapter1/02_a_swift_tour.html +++ b/chapter1/02_a_swift_tour.html @@ -46,7 +46,7 @@ -本页内容包括：
diff --git a/chapter1/chapter1.html b/chapter1/chapter1.html index da0b03aa..7f62a34d 100644 --- a/chapter1/chapter1.html +++ b/chapter1/chapter1.html @@ -46,7 +46,7 @@ -在本章中您将了解 Swift 的特性和开发历史，并对 Swift 有一个初步的了解。
diff --git a/chapter2/01_The_Basics.html b/chapter2/01_The_Basics.html index 4af1adce..50fd12d1 100644 --- a/chapter2/01_The_Basics.html +++ b/chapter2/01_The_Basics.html @@ -46,7 +46,7 @@ -Swift 是 iOS 和 OS X 应用开发的一门新语言。然而，如果你有 C 或者 Objective-C 开发经验的话，你会发现 Swift 的很多内容都是你熟悉的。
diff --git a/chapter2/02_Basic_Operators.html b/chapter2/02_Basic_Operators.html index 69c48de4..898bf729 100644 --- a/chapter2/02_Basic_Operators.html +++ b/chapter2/02_Basic_Operators.html @@ -46,7 +46,7 @@ -运算符是检查, 改变, 合并值的特殊符号或短语. 例如, 加号 + 把计算两个数的和(如 let i = 1 + 2). 复杂些的运行算包括逻辑与&&(如 if enteredDoorCode && passedRetinaScan), 还有自增运算符 ++i 这样让自身加一的便捷运算.
本页包含内容：
diff --git a/chapter2/04_Collection_Types.html b/chapter2/04_Collection_Types.html index a74b8013..3ada979b 100644 --- a/chapter2/04_Collection_Types.html +++ b/chapter2/04_Collection_Types.html @@ -46,7 +46,7 @@ -本页包含内容：
@@ -590,7 +590,7 @@函数是用来完成特定任务的独立的代码块。你给一个函数起一个合适的名字，用来标示函数做什么，并且当函数需要执行的时候，这个名字会被“调用”。
Swift统一的函数语法足够灵活，可以用来表示任何函数，包括从最简单的没有参数名字的C风格函数，到复杂的带局部和外部参数名的Objective-C风格函数。参数可以提供默认值，以简化函数调用。参数也可以即当做传入参数，也当做传出参数，也就是说，一旦函数执行结束，传入的参数值可以被修改。
在Swift中，每个函数都有一种类型，包括函数的参数值类型和返回值类型。你可以把函数类型当做任何其他普通变量类型一样处理，这样就可以更简单地把函数当做别的函数的参数，也可以从其他函数中返回函数。函数的定义可以写在在其他函数定义中，这样可以在嵌套函数范围内实现功能封装。
-当你定义一个函数时，你可以定义一个或多个有名字和类型的值，作为函数的输入（称为参数，parameters），也可以定义某种类型的值作为函数执行结束的输出（称为返回类型）。
每个函数有个函数名，用来描述函数执行的任务。要使用一个函数时，你用函数名“调用”，并传给它匹配的输入值（称作实参，arguments）。一个函数的实参必须与函数参数表里参数的顺序一致。
在下面例子中的函数叫做"greetingForPerson"，之所以叫这个名字是因为这个函数用一个人的名字当做输入，并返回给这个人的问候语。为了完成这个任务，你定义一个输入参数-一个叫做personName的String值，和一个包含给这个人问候语的String类型的返回值：
函数参数与返回值在Swift中极为灵活。你可以定义任何类型的函数，包括从只带一个未名参数的简单函数到复杂的带有表达性参数名和不同参数选项的复杂函数。
+函数可以有多个输入参数，写在圆括号中，用逗号分隔。
+下面这个函数用一个半开区间的开始点和结束点，计算出这个范围内包含多少数字：
+ func halfOpenRangeLength(start: Int, end: Int) -> Int {
+ return end - start
+ }
+ println(halfOpenRangeLength(1, 10))
+ // prints "9
+函数可以没有参数。下面这个函数就是一个无参函数，当被调用时，它返回固定的String消息：
func sayHelloWorld() -> String {
+ return "hello, world"
+ }
+ println(sayHelloWorld())
+ // prints "hello, world
+尽管这个函数没有参数，但是定义中在函数名后还是需要一对圆括号。当被调用时，也需要在函数名后写一对圆括号。
+函数可以没有返回值。下面是sayHello函数的另一个版本，叫waveGoodbye，这个函数直接输出String值，而不是返回它：
func sayGoodbye(personName: String) {
+ println("Goodbye, \(personName)!")
+ }
+ sayGoodbye("Dave")
+ // prints "Goodbye, Dave!
+因为这个函数不需要返回值，所以这个函数的定义中没有返回箭头（->）和返回类型。
+++注意： +严格上来说，虽然没有返回值被定义，
+sayGoodbye函数依然返回了值。没有定义返回类型的函数会返回特殊的值，叫Void。它其实是一个空的元组（tuple），没有任何元素，可以写成()。
被调用时，一个函数的返回值可以被忽略：
+ func printAndCount(stringToPrint: String) -> Int {
+ println(stringToPrint)
+ return countElements(stringToPrint)
+ }
+ func printWithoutCounting(stringToPrint: String) {
+ printAndCount(stringToPrint)
+ }
+ printAndCount("hello, world")
+ // prints "hello, world" and returns a value of 12
+ printWithoutCounting("hello, world")
+ // prints "hello, world" but does not return a value
+第一个函数printAndCount，输出一个字符串并返回Int类型的字符数。第二个函数printWithoutCounting调用了第一个函数，但是忽略了它的返回值。当第二个函数被调用时，消息依然会由第一个函数输出，但是返回值不会被用到。
++注意： +返回值可以被忽略，但定义了有返回值的函数必须返回一个值，如果在函数定义底部没有返回任何值，这叫导致编译错误（compile-time error）。
+
你可以用元组（tuple）类型让多个值作为一个复合值从函数中返回。
+下面的这个例子中，count函数用来计算一个字符串中元音，辅音和其他字母的个数（基于美式英语的标准）。
func count(string: String) -> (vowels: Int, consonants: Int, others: Int) {
+ var vowels = 0, consonants = 0, others = 0
+ for character in string {
+ switch String(character).lowercaseString {
+ case "a", "e", "i", "o", "u":
+ ++vowels
+ case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
+ "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
+ ++consonants
+ default:
+ ++others
+ }
+ }
+ return (vowels, consonants, others)
+ }
+你可以用count函数来处理任何一个字符串，返回的值将是一个包含三个Int型值的元组（tuple）：
let total = count("some arbitrary string!")
+ println("\(total.vowels) vowels and \(total.consonants) consonants")
+ // prints "6 vowels and 13 consonants
+需要注意的是，元组的成员不需要在函数中返回时命名，因为它们的名字已经在函数返回类型有有了定义。
+以上所有的函数都给它们的参数定义了参数名（parameter name）：
func someFunction(parameterName: Int) {
+ // function body goes here, and can use parameterName
+ // to refer to the argument value for that parameter
+ }
+但是，这些参数名仅在函数体中使用，不能在函数调用时使用。这种类型的参数名被称作局部参数名（local parameter name），因为它们只能在函数体中使用。
有时候，调用函数时，给每个参数命名是非常有用的，因为这些参数名可以指出各个实参的用途是什么。
+如果你希望函数的使用者在调用函数时提供参数名字，那就需要给每个参数除了局部参数名外再定义一个外部参数名。外部参数名写在局部参数名之前，用空格分隔。
func someFunction(externalParameterName localParameterName: Int) {
+ // function body goes here, and can use localParameterName
+ // to refer to the argument value for that parameter
+ }
+++注意： +如果你提供了外部参数名，那么函数在被调用时，必须使用外部参数名。
+
以下是个例子，这个函数使用一个结合者（joiner）把两个字符串联在一起：
func join(s1: String, s2: String, joiner: String) -> String {
+ return s1 + joiner + s2
+ }
+当你调用这个函数时，这三个字符串的用途是不清楚的：
+ join("hello", "world", ", ")
+ // returns "hello, world
+为了让这些字符串的用途更为明显，我们为join函数添加外部参数名：
func join(string s1: String, toString s2: String, withJoiner joiner: String) -> String {
+ return s1 + joiner + s2
+ }
+在这个版本的join函数中，第一个参数有一个叫string的外部参数名和s1的局部参数名，第二个参数有一个叫toString的外部参数名和s2的局部参数名，第三个参数有一个叫withJoiner的外部参数名和joiner的局部参数名。
现在，你可以使用这些外部参数名以一种清晰地方式来调用函数了：
+ join(string: "hello", toString: "world", withJoiner: ", ")
+ // returns "hello, world
+使用外部参数名让第二个版本的join函数的调用更为有表现力，更为通顺，同时还保持了函数体是可读的和有明确意图的。
++注意： +当其他人在第一次读你的代码，函数参数的意图显得不明显时，考虑使用外部参数名。如果函数参数名的意图是很明显的，那就不需要定义外部参数名了。
+
如果你需要提供外部参数名，但是局部参数名已经定义好了，那么你不需要写两次这些参数名。相反，只写一次参数名，并用井号（#）作为前缀就可以了。这告诉Swift使用这个参数名作为局部和外部参数名。
下面这个例子定义了一个叫containsCharacter的函数，使用井号（#）的方式定义了外部参数名：
func containsCharacter(#string: String, #characterToFind: Character) -> Bool {
+ for character in string {
+ if character == characterToFind {
+ return true
+ }
+ }
+ return false
+ }
+这样定义参数名，使得函数体更为可读，清晰，同时也可以以一个不含糊的方式被调用：
+ let containsAVee = containsCharacter(string: "aardvark", characterToFind: "v")
+ // containsAVee equals true, because "aardvark" contains a "v”
+你可以在函数体中为每个参数定义默认值。当默认值被定义后，调用这个函数时可以略去这个参数。
++注意： +将带有默认值的参数放在函数参数表的最后。这样可以保证在函数调用时，非默认参数的顺序是一致的，同时使得相同的函数在不同情况下调用时显得更为清晰。
+
以下是另一个版本的join函数，其中joiner有了默认参数值：
func join(string s1: String, toString s2: String, withJoiner joiner: String = " ") -> String {
+ return s1 + joiner + s2
+ }
+像第一个版本的join函数一样，如果joiner被幅值时，函数将使用这个字符串值来连接两个字符串：
join(string: "hello", toString: "world", withJoiner: "-")
+ // returns "hello-world
+当这个函数被调用时，如果joiner的值没有被指定，函数会使用默认值（" "）：
join(string: "hello", toString: "world", withJoiner: "-")
+ // returns "hello-world
+在大多数情况下，给带默认值的参数起一个外部参数名是很有用的。这样可以保证当函数被调用且带默认值的参数被提供值时，实参的意图是明显的。
+为了使定义外部参数名更加简单，当你未给带默认值的参数提供外部参数名时，Swift会自动提供外部名字。此时外部参数名与局部名字是一样的，就像你已经在局部参数名前写了井号（#）一样。
下面是join函数的另一个版本，这个版本中并没有为它的参数提供外部参数名，但是joiner参数依然有外部参数名：
func join(s1: String, s2: String, joiner: String = " ") -> String {
+ return s1 + joiner + s2
+ }
+在这个例子中，Swift自动为joiner提供了外部参数名。因此，当函数调用时，外部参数名必须使用，这样使得参数的用途变得清晰。
func join(s1: String, s2: String, joiner: String = " ") -> String {
+ return s1 + joiner + s2
+ }
+++注意： +你可以使用
+下划线（_）作为默认值参数的外部参数名，这样可以在调用时不用提供外部参数名。但是给带默认值的参数命名总是更加合适的。
一个可变参数（variadic parameter）可以接受一个或多个值。函数调用时，你可以用可变参数来传入不确定数量的输入参数。通过在变量类型名后面加入（...）的方式来定义可变参数。
传入可变参数的值在函数体内当做这个类型的一个数组。例如，一个叫做numbers的Double...型可变参数，在函数体内可以当做一个叫numbers的Double[]型的数组常量。
下面的这个函数用来计算一组任意长度数字的算术平均数：
+ func arithmeticMean(numbers: Double...) -> Double {
+ var total: Double = 0
+ for number in numbers {
+ total += number
+ }
+ return total / Double(numbers.count)
+ }
+ arithmeticMean(1, 2, 3, 4, 5)
+ // returns 3.0, which is the arithmetic mean of these five numbers
+ arithmeticMean(3, 8, 19)
+ // returns 10.0, which is the arithmetic mean of these three numbers
+++注意： +一个函数至多能有一个可变参数，而且它必须是参数表中最后的一个。这样做是为了避免函数调用时出现歧义。
+
如果函数有一个或多个带默认值的参数，而且还有一个可变参数，那么把可变参数放在参数表的最后。
+函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误。这意味着你不能错误地更改参数值。
+但是，有时候，如果函数中有传入参数的变量值副本将是很有用的。你可以通过指定一个或多个参数为变量参数，从而避免自己在函数中定义新的变量。变量参数不是常量，你可以在函数中把它当做新的可修改副本来使用。
+通过在参数名前加关键字var来定义变量参数：
func alignRight(var string: String, count: Int, pad: Character) -> String {
+ let amountToPad = count - countElements(string)
+ for _ in 1...amountToPad {
+ string = pad + string
+ }
+ return string
+ }
+ let originalString = "hello"
+ let paddedString = alignRight(originalString, 10, "-")
+ // paddedString is equal to "-----hello"
+ // originalString is still equal to "hello”
+这个例子中定义了一个新的叫做alignRight的函数，用来右对齐输入的字符串到一个长的输出字符串中。左侧空余的地方用指定的填充字符填充。这个例子中，字符串"hello"被转换成了"-----hello"。
alignRight函数将参数string定义为变量参数。这意味着string现在可以作为一个局部变量，用传入的字符串值初始化，并且可以在函数体中进行操作。
该函数首先计算出多少个字符需要被添加到string的左边，以右对齐到总的字符串中。这个值存在局部常量amountToPad中。这个函数然后将amountToPad多的填充（pad）字符填充到string左边，并返回结果。它使用了string这个变量参数来进行所有字符串操作。
++注意： +对变量参数所进行的修改在函数调用结束后变消息了，并且对于函数体外是不可见的。变量参数仅仅存在于函数调用的生命周期中。
+
变量参数，正如上面所述，仅仅能在函数体内被更改。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）。
+定义一个输入输出参数时，在参数定以前加inout关键字。一个输入输出参数有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值。
你只能传入一个变量作为输入输出参数。你不能传入常量或者字面量（literal value），因为这些量是不能被修改的。当传入的参数作为输入输出参数时，需要在参数前加&符，表示这个值可以被函数修改。
++注意： +输入输出参数不能有默认值，而且变量参数不能用
+inout标记。如果你用inout标记一个参数，这个参数不能别var或者let标记。
下面是例子，swapTwoInts函数，有两个分别叫做a和b的输出输出参数：
func swapTwoInts(inout a: Int, inout b: Int) {
+ let temporaryA = a
+ a = b
+ b = temporaryA
+ }
+这个swapTwoInts函数仅仅交换a与b的值。该函数先将a的值存到一个暂时常量temporaryA中，然后将b的值赋给a，最后将temporaryA幅值给b。
你可以用两个Int型的变量来调用swapTwoInts。需要注意的是，someInt和anotherInt在传入swapTwoInts函数前，都加了&的前缀：
var someInt = 3
+ var anotherInt = 107
+ swapTwoInts(&someInt, &anotherInt)
+ println("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
+ // prints "someInt is now 107, and anotherInt is now 3”
+从上面这个例子中，我们可以看到someInt和anotherInt的原始值在swapTwoInts函数中被修改，尽管它们的定义在函数体外。
++注意： +输出输出参数和返回值是不一样的。上面的
+swapTwoInts函数并没有定义任何返回值，但仍然修改了someInt和anotherInt的值。输入输出参数是函数对函数体外产生影响的另一种方式。
每个函数都有种特定的函数类型，由函数的参数类型和返回类型组成。
+例如：
+ func addTwoInts(a: Int, b: Int) -> Int {
+ return a + b
+ }
+ func multiplyTwoInts(a: Int, b: Int) -> Int {
+ return a * b
+ }
+这个例子中定义了两个简单的数学函数：addTwoInts和multiplyTwoInts。这两个函数都传入两个Int类型， 返回一个合适的Int值。
这两个函数的类型是(Int, Int) -> Int，可以读作“这个函数类型，它有两个Int型的参数并返回一个Int型的值。”。
下面是另一个例子，一个没有参数，也没有返回值的函数：
+ func printHelloWorld() {
+ println("hello, world")
+ }
+这个函数的类型是：() -> ()，或者叫“没有参数，并返回Void类型的函数。”。没有指定返回类型的函数总返回 Void。在Swift中，Void与空的元组是一样的。
在Swift中，使用函数类型就像使用其他类型一样。例如，你可以定义一个常量或变量，它的类型是函数，并且可以幅值为一个函数：
+ var mathFunction: (Int, Int) -> Int = addTwoInts
+这个可以读作：
+“定义一个叫做mathFunction的变量，类型是‘一个有两个Int型的参数并返回一个Int型的值的函数’，并让这个新变量指向addTwoInts函数”。
addTwoInts和mathFunction有同样的类型，所以这个赋值过程在Swift类型检查中是允许的。
现在，你可以用mathFunction来调用被赋值的函数了：
println("Result: \(mathFunction(2, 3))")
+ // prints "Result: 5
+有相同匹配类型的不同函数可以被赋值给同一个变量，就像非函数类型的变量一样：
+ mathFunction = multiplyTwoInts
+ println("Result: \(mathFunction(2, 3))")
+ // prints "Result: 6"
+就像其他类型一样，当赋值一个函数给常量或变量时，你可以让Swift来推测其函数类型：
+ let anotherMathFunction = addTwoInts
+ // anotherMathFunction is inferred to be of type (Int, Int) -> Int
+你可以用(Int, Int) -> Int这样的函数类型作为另一个函数的参数类型。这样你可以将函数的一部分实现交由给函数的调用者。
下面是另一个例子，正如上面的函数一样，同样是输出某种数学运算结果：
+ func printMathResult(mathFunction: (Int, Int) -> Int, a: Int, b: Int) {
+ println("Result: \(mathFunction(a, b))")
+ }
+ printMathResult(addTwoInts, 3, 5)
+ // prints "Result: 8”
+这个例子定义了printMathResult函数，它有三个参数：第一个参数叫mathFunction，类型是(Int, Int) -> Int，你可以传入任何这种类型的函数；第二个和第三个参数叫a和b，它们的类型都是Int，这两个值作为已给的函数的输入值。
当printMathResult被调用时，它被传入addTwoInts函数和整数3和5。它用传入3和5调用addTwoInts，并输出结果：8。
printMathResult函数的作用就是输出另一个合适类型的数学函数的调用结果。它不关心传入函数是如何实现的，它只关心这个传入的函数类型是正确的。这使得printMathResult可以以一种类型安全（type-safe）的方式来保证传入函数的调用是正确的。
你可以用函数类型作为另一个函数的返回类型。你需要做的是在返回箭头（->）后写一个完整的函数类型。
下面的这个例子中定义了两个简单函数，分别是stepForward和stepBackward。stepForward函数返回一个比输入值大一的值。stepBackward函数返回一个比输入值小一的值。这两个函数的类型都是(Int) -> Int：
func stepForward(input: Int) -> Int {
+ return input + 1
+ }
+ func stepBackward(input: Int) -> Int {
+ return input - 1
+ }
+下面这个叫做chooseStepFunction的函数，它的返回类型是(Int) -> Int的函数。chooseStepFunction根据布尔值backwards来返回stepForward函数或stepBackward函数：
func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
+ return backwards ? stepBackward : stepForward
+ }
+你现在可以用chooseStepFunction来获得一个函数，不管是那个方向：
var currentValue = 3
+ let moveNearerToZero = chooseStepFunction(currentValue > 0)
+ // moveNearerToZero now refers to the stepBackward() function
+上面这个例子中计算出从currentValue逐渐接近到0是需要向正数走还是向负数走。currentValue的初始值是3，这意味着currentValue > 0是真的（true），这将使得chooseStepFunction返回stepBackward函数。一个指向返回的函数的引用保存在了moveNearerToZero常量中。
现在，moveNearerToZero指向了正确的函数，它可以被用来数到0：
println("Counting to zero:")
+ // Counting to zero:
+ while currentValue != 0 {
+ println("\(currentValue)... ")
+ currentValue = moveNearerToZero(currentValue)
+ }
+ println("zero!")
+ // 3...
+ // 2...
+ // 1...
+ // zero!
+这章中你所见到的所有函数都叫全局函数（global functions），它们定义在全局域中。你也可以把函数定义在别的函数体中，称作嵌套函数（nested functions）。
+默认情况下，嵌套函数是对外界不可见的，但是可以被他们封闭函数（enclosing function）来调用。一个封闭函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用。
+你可以用返回嵌套函数的方式重写chooseStepFunction函数：
func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
+ func stepForward(input: Int) -> Int { return input + 1 }
+ func stepBackward(input: Int) -> Int { return input - 1 }
+ return backwards ? stepBackward : stepForward
+ }
+ var currentValue = -4
+ let moveNearerToZero = chooseStepFunction(currentValue > 0)
+ // moveNearerToZero now refers to the nested stepForward() function
+ while currentValue != 0 {
+ println("\(currentValue)... ")
+ currentValue = moveNearerToZero(currentValue)
+ }
+ println("zero!")
+ // -4...
+ // -3...
+ // -2...
+ // -1...
+ // zero!
+本页内容包含：
diff --git a/chapter2/08_Enumerations.html b/chapter2/08_Enumerations.html index 7e3e5205..12c70989 100644 --- a/chapter2/08_Enumerations.html +++ b/chapter2/08_Enumerations.html @@ -46,7 +46,7 @@ -本页包含内容：
diff --git a/chapter2/10_Properties.html b/chapter2/10_Properties.html index 91628ed0..c4c61eee 100644 --- a/chapter2/10_Properties.html +++ b/chapter2/10_Properties.html @@ -46,7 +46,7 @@ -本页包含内容：
diff --git a/chapter2/17_Optional_Chaining.html b/chapter2/17_Optional_Chaining.html index 51f3e91f..c390aba1 100644 --- a/chapter2/17_Optional_Chaining.html +++ b/chapter2/17_Optional_Chaining.html @@ -46,7 +46,7 @@ -（ps：为了方便各位检验所以保留了英文，可删。） diff --git a/chapter2/19_Nested_Types.html b/chapter2/19_Nested_Types.html index 487d1721..222a6dcf 100644 --- a/chapter2/19_Nested_Types.html +++ b/chapter2/19_Nested_Types.html @@ -46,7 +46,7 @@ -
本页包含内容：
diff --git a/chapter2/20_Extensions.html b/chapter2/20_Extensions.html index 8ef67860..f5b413cc 100644 --- a/chapter2/20_Extensions.html +++ b/chapter2/20_Extensions.html @@ -46,7 +46,7 @@ -本章介绍了 Swift 的各种特性及其使用方法，是全书的核心部分。
diff --git a/chapter3/01_About_the_Language_Reference.html b/chapter3/01_About_the_Language_Reference.html index 2a87d1cf..77e309a1 100644 --- a/chapter3/01_About_the_Language_Reference.html +++ b/chapter3/01_About_the_Language_Reference.html @@ -46,7 +46,7 @@ -本书的这一节描述了Swift编程语言的形式语法。这里描述的语法是为了帮助您更详细的了解该语言，而不是让您直接实现一个解析器或编译器。
diff --git a/chapter3/02_Lexical_Structure.html b/chapter3/02_Lexical_Structure.html index f0fce964..5efc39d5 100644 --- a/chapter3/02_Lexical_Structure.html +++ b/chapter3/02_Lexical_Structure.html @@ -46,7 +46,7 @@ -Swift 是苹果在 WWDC 2014 上发布的一款全新的编程语言，本书译自苹果官方的 Swift 教程《The Swift Programming Language》。
diff --git a/manifest.appcache b/manifest.appcache index e75f0c30..dbe74e42 100644 --- a/manifest.appcache +++ b/manifest.appcache @@ -1,5 +1,5 @@ CACHE MANIFEST -# Revision 1402148739560 +# Revision 1402183329826 CACHE: index.html diff --git a/search_index.json b/search_index.json index 139c62b9..654eafe9 100644 --- a/search_index.json +++ b/search_index.json @@ -1 +1 @@ -{"version":"0.5.2","fields":[{"name":"title","boost":10},{"name":"body","boost":1}],"ref":"url","documentStore":{"store":{"index.html#gitbook_5":["2014","languag","program","swift","undefinedundefin","wwdc"],"chapter1/01_swift.html#gitbook_6":["arc","automat","c","cocoa","cocoa的基础上构建框架栈并将其标准化。objective-c","count","c的兼容性的限制。swift","foundat","hello","io","objective-c","os","refer","swift","touch","undefinedundefin","world","x"],"chapter1/02_a_swift_tour.html#gitbook_7":["0","0..3","0..time","0.0","1","10","100","103","11","12","13","16","19","2","2.5","20","25","3","3.0","3.1","3.59","3.69","3.79","4","42","43","5","5.2","50","597","69105","7","7.simpledescript","70","70.0","75","8","87","8:09","9","9.9","94","a.adjust","a.simpledescript","ac","ace.toraw","acerawvalu","add","addon","addone(numb","adescript","adjust","amount","anoth","anotherproperti","ant","anycommonel","anycommonelements([1","appl","applese","applesummari","area","b","b.adjust","b.simpledescript","bdescript","blue","bool","bottl","c","captain","card","card(rank","card添加一个方法，创建一副完整的扑克牌并把每张牌的rank和suit","case","catfish","celeri","chees","class","club","condit","condition(item","convertedrank","convertedrank.simpledescript","count","counter","counter.incrementby(2","cucumb","dai","default","deinit","diamond","dictionary