Swift 是一种新的编程语言，用于编写 iOS 和 OS X 应用程序。Swift 结合了 C 和 Objective-C 的优点并且不受C的兼容性的限制。Swift 使用安全的编程模式并添加了很多新特性，这将使编程更简单，扩展性更强，也更有趣。除此之外，Swift 还支持人见人爱的 Cocoa 和 Cocoa Touch 框架。拥有了这些特性，Swift将重新定义软件开发。
+Swift 是一种新的编程语言，用于编写 iOS 和 OS X 应用。Swift 结合了 C 和 Objective-C 的优点并且不受C的兼容性的限制。Swift 使用安全的编程模式并添加了很多新特性，这将使编程更简单，扩展性更强，也更有趣。除此之外，Swift 还支持人见人爱的 Cocoa 和 Cocoa Touch 框架。拥有了这些特性，Swift将重新定义软件开发。
Swift 的开发从很久之前就开始了。为了给 Swift 打好基础，苹果公司改进了编译器，调试器和框架结构。我们使用自动引用计数（Automatic Reference Counting, ARC）来简化内存管理。我们在 Foundation 和 Cocoa的基础上构建框架栈并将其标准化。Objective-C 本身支持块、集合语法和模块，所以框架可以轻松支持现代编程语言技术。得益于这些基础工作，我们现在可以发布一个新语言，用于未来的苹果软件的开发。
Objective-C 开发者对于 Swift 并不会感到陌生。它采用了 Objective-C 的命名参数以及动态对象模型，可以无缝对接到现有的 Cocoa 框架，并且可以兼容 Objective-C 代码。在此基础之上，Swift 还有许多新特性并且支持过程式编程和面向对象编程。
Swift 对于初学者来说也很友好。它是第一个既满足工业标准又像脚本语言一样充满表现力和趣味的编程语言。它支持代码预览，这个革命性的特性可以允许程序员在不编译和运行应用程序的前提下运行 Swift 代码并实时查看结果。
diff --git a/chapter1/02_a_swift_tour.html b/chapter1/02_a_swift_tour.html index f3d0dfe1..c5f181aa 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 76592772..8258bf82 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 106f9a9b..e668bebb 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 258be376..be47344f 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 747dbaae..bd23b6c1 100644 --- a/chapter2/04_Collection_Types.html +++ b/chapter2/04_Collection_Types.html @@ -46,7 +46,7 @@ -本页包含内容：
diff --git a/chapter2/07_Closures.html b/chapter2/07_Closures.html index 4559cbf2..80a03674 100644 --- a/chapter2/07_Closures.html +++ b/chapter2/07_Closures.html @@ -46,7 +46,7 @@ -本页内容包含：
diff --git a/chapter2/08_Enumerations.html b/chapter2/08_Enumerations.html index 4d6d8e58..dd3eeb89 100644 --- a/chapter2/08_Enumerations.html +++ b/chapter2/08_Enumerations.html @@ -46,7 +46,7 @@ -本页内容包含：
diff --git a/chapter2/09_Classes_and_Structures.html b/chapter2/09_Classes_and_Structures.html index 13a3dde8..5660807a 100644 --- a/chapter2/09_Classes_and_Structures.html +++ b/chapter2/09_Classes_and_Structures.html @@ -46,7 +46,7 @@ -本页包含内容：
diff --git a/chapter2/10_Properties.html b/chapter2/10_Properties.html index daae70dd..0e9fdf8b 100644 --- a/chapter2/10_Properties.html +++ b/chapter2/10_Properties.html @@ -46,7 +46,7 @@ -方法是与某些特定类型相关联的功能/函数。类、结构体、枚举都可以定义实例方法；实例方法为指定类型的实例封装了特定的任务与功能。类、结构体、枚举也可以定义类(型)方法(type itself)；类型方法与类型自身相关联。类型方法与Objective-C中的类方法(class methods)相似。
+在Swift中,结构体和枚举能够定义方法；事实上这是Swift与C/Objective-C的主要区别之一。在Objective-C中,类是唯一能定义方法的类型。在Swift中，你能够选择是否定义一个类/结构体/枚举，并且你仍然享有在你创建的类型(类/结构体/枚举)上定义方法的灵活性。
+实例方法是某个特定类、结构体或者枚举类型的实例的方法。实例方法支撑实例的功能: 或者提供方法,以访问和修改实例属性;或者提供与实例的目的相关的功能。实例方法的语法与函数完全一致，参考函数说明。
+实例方法要写在它所属的类型的前后括号之间。实例方法能够访问他所属类型的所有的其他实例方法和属性。实例方法只能被它所属的类的特定实例调用。实例方法不能被孤立于现存的实例而被调用。
+下面是定义一个很简单的类Counter的例子(Counter能被用来对一个动作发生的次数进行计数):
class Counter {
+ var count = 0
+ func increment() {
+ count++
+ }
+ func incrementBy(amount: Int) {
+ count += amount
+ }
+ func reset() {
+ count = 0
+ }
+}
+Counter类定理了三个实例方法：
increment让计数器按一递增；incrementBy(amount: Int)让计数器按一个指定的整数值递增；reset将计数器重置为0。Counter这个类还声明了一个可变属性count，用它来保持对当前计数器值的追踪。
和调用属性一样，用点语法(dot syntax)调用实例方法:
+ let counter = Counter()
+ // the initial counter value is 0
+ counter.increment()
+ // the counter's value is now 1
+ counter.incrementBy(5)
+ // the counter's value is now 6
+ counter.reset()
+ // the counter's value is now 0
+函数参数有一个局部名称(在函数体内部使用)和一个外部名称(在调用函数时使用),参考External Parameter Names。对于方法参数也是这样，因为方法就是函数(只是这个函数与某个类型相关联了)。但是，方法和函数的局部名称和外部名称的默认行为是不一样的。
+Swift中的方法和Objective-C中的方法极其相似。像在Objective-C中一样，Swift中方法的名称通常用一个介词指向方法的第一个参数，比如：with,for,by等等。前面的Counter类的例子中incrementBy方法就是这样的。介词的使用让方法在被调用时能像一个句子一样被解读。Swift这种方法命名约定很容易落实,因为它是用不同的默认处理方法参数的方式，而不是用函数参数(来实现的)。
具体来说，Swift默认仅给方法的第一个参数名称一个局部参数名称;但是默认同时给第二个和后续的参数名称局部参数名称和外部参数名称。 +这个约定与典型的命名和调用约定相匹配，这与你在写Objective-C的方法时很相似。这个约定还让expressive method调用不需要再检查/限定参数名。
+看看下面这个Counter的替换版本（它定义了一个更复杂的incrementBy方法）：
class Counter {
+ var count: Int = 0
+ func incrementBy(amount: Int, numberOfTimes: Int) {
+ count += amount * numberOfTimes
+ }
+}
+incrementBy方法有两个参数： amount和numberOfTimes。默认地，Swift只把amount当作一个局部名称，但是把numberOfTimes即看作本地名称又看作外部名称。下面调用这个方法：
let counter = Counter()
+counter.incrementBy(5, numberOfTimes: 3)
+// counter value is now 15
+你不必为第一个参数值再定义一个外部变量名：因为从函数名incrementBy已经能很清楚地看出它的目的/作用。但是第二个参数，就要被一个外部参数名称所限定,以便在方法被调用时让他目的/作用明确。
这种默认的行为能够有效的检查方法，比如你在参数numberOfTimes前写了个井号( # )时:
func incrementBy(amount: Int, #numberOfTimes: Int) {
+ count += amount * numberOfTimes
+}
+这种默认行为使上面代码意味着：在Swift中定义方法使用了与Objective-C同样的语法风格，并且方法将以自然表达式的方式被调用。
+有时为方法的第一个参数提供一个外部参数名称是非常有用的，尽管这不是默认的行为。你可以自己添加一个明确的外部名称;你也可以用一个hash符号作为第一个参数的前缀，然后用这个局部名字作为外部名字。
+相反，如果你不想为方法的第二个及后续的参数提供一个外部名称，你可以通过使用下划线(_)作为该参数的显式外部名称来覆盖默认行为。
self属性(The self Property)类型的每一个实例都有一个隐含属性叫做self，它完全等同于这个实力变量本身。你可以在一个实例的实例方法中使用这个隐含的self属性来引用当前实例。
上面例子中的increment方法可以被写成这样：
func increment() {
+ self.count++
+}
+实际上，你不必在你的代码里面经常写self。不论何时，在一个方法中使用一个已知的属性或者方法名称，如果你没有明确的写self，Swift假定你是指当前实例的属性或者方法。这种假定在上面的Counter中已经示范了：Counter中的三个实例方法中都使用的是count(而不是self.count)
这条规则的主要例外发生在当实例方法的某个参数名称与实例的某个属性名称相同时。
+在这种情况下，参数名称享有优先权，并且在引用属性时必须使用一种更恰当(被限定更严格)的方式。
+你可以使用隐藏的self属性来区分参数名称和属性名称。
下面的例子演示了self消除方法参数x和实例属性x之间的歧义：
struct Point {
+ var x = 0.0, y = 0.0
+ func isToTheRightOfX(x: Double) -> Bool {
+ return self.x > x
+ }
+}
+let somePoint = Point(x: 4.0, y: 5.0)
+if somePoint.isToTheRightOfX(1.0) {
+ println("This point is to the right of the line where x == 1.0")
+}
+// prints "This point is to the right of the line where x == 1.0"
+如果不使用self前缀，Swift就认为两次使用的x都指的是名称为x的函数参数。
结构体和枚举是值类型Structures and Enumerations Are Value Types。一般情况下，值类型的属性不能在他的实例方法中被修改。
+但是，如果你确实需要在某个具体的方法中修改结构体或者枚举的属性，你可以选择变异(mutating)这个方法。方法可以从内部变异它的属性；并且它做的任何改变在方法结束时都会回写到原始结构。方法会给它隐含的self属性赋值一个全新的实例,这个新实例在方法结束后将替换原来的实例。
要变异方法, 将关键字mutating 放到方法的func关键字之前就可以了：
struct Point {
+ var x = 0.0, y = 0.0
+ mutating func moveByX(deltaX: Double, y deltaY: Double) {
+ x += deltaX
+ y += deltaY
+ }
+}
+var somePoint = Point(x: 1.0, y: 1.0)
+somePoint.moveByX(2.0, y: 3.0)
+println("The point is now at (\(somePoint.x), \(somePoint.y))")
+// prints "The point is now at (3.0, 4.0)"
+上面的Point结构体定义了一个变异方法(mutating method)moveByX，moveByX用来移动一个point。moveByX方法在被调用时修改了这个point,而不是返回一个新的point。方法定义是加上那个了mutating关键字,所以方法可以修改值类型的属性了。
注意：不能在结构体类型的常量上调用变异方法,因为常量的属性不能被改变,就算你想改变的是常量的可变属性也不行，参考Stored Properties of Constant Structure Instances
+let fixedPoint = Point(x: 3.0, y: 3.0)
+fixedPoint.moveByX(2.0, y: 3.0)
+// this will report an error
+变异方法能够赋给隐含属性self一个全新的实例。上面Point的例子可以用下面的方式改写：
struct Point {
+ var x = 0.0, y = 0.0
+ mutating func moveByX(deltaX: Double, y deltaY: Double) {
+ self = Point(x: x + deltaX, y: y + deltaY)
+ }
+}
+新版的变异方法moveByX创建了一个新的分支结构(他的x和y的值都被设定为目标值了)。调用这个版本的方法和调用上个版本的最终结果是一样的。
枚举的变异方法可以让self从相同的枚举设置为不同的成员。
enum TriStateSwitch {
+ case Off, Low, High
+ mutating func next() {
+ switch self {
+ case Off:
+ self = Low
+ case Low:
+ self = High
+ case High:
+ self = Off
+ }
+ }
+}
+var ovenLight = TriStateSwitch.Low
+ovenLight.next()
+// ovenLight is now equal to .High
+ovenLight.next()
+// ovenLight is now equal to .Off
+上面的例子中定义了一个三态开关的枚举。每次调用next方法时，开关在不同的电源状态(Off,Low,High)之前循环切换。
实例方法是被类型的某个实例调用的方法。你也可以定义类列本身调用的方法，这种方法就叫做类型方法。声明类的类型方法，在方法的func关键字之前加上关键字class；声明结构体和枚举的类型方法，在方法的func关键字之前加上关键字static。
++注意：
+在Objective-C里面，你只能为Objective-C的类定义类型方法(type-level methods)。在Swift中，你可以为所有的类、结构体和枚举定义类型方法：Each type method is explicitly scoped to the type it supports.
+
类型方法和实例方法一样用点语法调用。但是，你是在类型上调用这个方法，而不是在实例上调用。下面是如何在SomeClass类上调用类型方法的例子：
+class SomeClass {
+ class func someTypeMethod() {
+ // type method implementation goes here
+ }
+}
+SomeClass.someTypeMethod()
+在类型方法的方法体(body)中，self指向这个类型本身，而不是类型的某个实例。对于结构体和枚举来说，这意味着你可以用self来消除静态属性和静态方法参数之间的二意性(类似于我们在前面处理实例属性和实例方法参数时做的那样)。
一般地，在类型方法里面所使用的任何未限定的方法和属性名称，将会指向其他的类型级别的方法和属性。一个类型方法可以用另一个类型方法的名称调用踏，而无需在方法名称前面加上类型名称的前缀。同样，结构体和枚举的类型方法也能够直接通过静态属性的名称访问静态属性，而不需要类型名称前缀。
+下面的例子定义了一个名为LevelTracker结构体。它监测玩家的发展情况(游戏的不同层次或阶段)。这是一个单人游戏，但也可以用作多玩家游戏中单个设备上的信息存储。
游戏初始时，所有的游戏等级(除了等级1)都被锁定。每次有玩家完成一个等级，这个等级就对这个设备上的所有玩家解锁。LevelTracker结构体用静态属性和方法监测游戏的哪个等级已经被解锁。他还监测每个玩家的当前等级。
struct LevelTracker {
+ static var highestUnlockedLevel = 1
+ static func unlockLevel(level: Int) {
+ if level > highestUnlockedLevel { highestUnlockedLevel = level }
+ }
+ static func levelIsUnlocked(level: Int) -> Bool {
+ return level <= highestUnlockedLevel
+ }
+ var currentLevel = 1
+ mutating func advanceToLevel(level: Int) -> Bool {
+ if LevelTracker.levelIsUnlocked(level) {
+ currentLevel = level
+ return true
+ } else {
+ return false
+ }
+ }
+}
+LevelTracker监测玩家的已解锁的最高等级。这个值被存储在静态属性highestUnlockedLevel中。
LevelTracker还定义了两个类型方法与highestUnlockedLevel配合工作。第一个类型方法是unlockLevel：一旦新等级被解锁，它会更新highestUnlockedLevel的值。第二个类型方法是levelIsUnlocked：如果某个给定的等级已经被解锁，他返回true。(注意：我们没用使用LevelTracker.highestUnlockedLevel，这个类型方法还是能够访问静态属性highestUnlockedLevel)
除了静态属性和类型方法，LevelTracker还监测每个玩家的进度。它用实例属性currentLevel来监测玩家当前正在进行的等级。
为了便于管理currentLevel属性，LevelTracker定义了实例方法advanceToLevel。这个方法会在更新currentLevel之前检查所请求的新等级是否已经解锁。advanceToLevel方法返回布尔值以指示是否确实能够设置currentLevel了。
下面，Player类使用LevelTracker来监测和更新每个玩家的发展进度：
class Player {
+ var tracker = LevelTracker()
+ let playerName: String
+ func completedLevel(level: Int) {
+ LevelTracker.unlockLevel(level + 1)
+ tracker.advanceToLevel(level + 1)
+ }
+ init(name: String) {
+ playerName = name
+ }
+}
+Player类创建一个新的LevelTracker实例来检测这个用户的发展进度。他提供了completedLevel方法：一旦玩家完成某个指定等级就调用它。这个方法为所有玩家解锁下一等级，并且将当前玩家的进度更新为下一等级。（我们忽略了advanceToLevel返回的布尔值，因为之前调用LevelTracker.unlockLevel时就知道了这个等级已经被解锁了）
你还可以为一个新的玩家创建一个Player的实例，然后看这个玩家完成等级一时发生了什么：
var player = Player(name: "Argyrios")
+player.completedLevel(1)
+println("highest unlocked level is now \(LevelTracker.highestUnlockedLevel)")
+// prints "highest unlocked level is now 2"
+如果你创建了第二个玩家，并尝试让他开始一个没有被任何玩家解锁的等级，你试图去设置玩家当前等级时会失败的：
+player = Player(name: "Beto")
+if player.tracker.advanceToLevel(6) {
+println("player is now on level 6")
+} else {
+println("level 6 has not yet been unlocked")
+}
+// prints "level 6 has not yet been unlocked"
+下标可以定义在类(Class)、结构体(structures)和枚举(enumerations)这些目标中，可以认为是访问对象、集合或序列的快捷方式。举例来说，用下标访问一个数组(Array)实例中的元素可以这样写 someArray[index] ，访问字典(Dictionary)实例中的元素可以这样写 someDictionary[key]，而不需要再调用实例的某个方法来获得元素的值。
对于同一个目标可以定义多个下标，通过索引值类型的不同来进行重载，而且索引值的个数可以是多个。
+++译者：这里下标重载在本小节中原文并没有任何演示
+
下标允许你通过在实例后面的方括号中传入一个或者多个的索引值来对实例进行访问和赋值。语法类似于实例方法和实例属性的混合。与定义实例方法类似，定义下标使用subscript关键字，显式声明入参（一个或多个）和返回类型。与实例方法不同的是下标可以设定为读写或只读。这种方式又有点像实例属性的getter和setter：
subscript(index: Int) -> Int {
+ get {
+ // 返回与入参匹配的Int类型的值
+ }
+
+ set(newValue) {
+ // 执行赋值操作
+ }
+}
+newValue的类型必须和下标定义的返回类型相同。与实例属性相同的是set的入参声明newValue就算不写，在set代码块中依然可以使用newValue这个变量来访问新赋的值。
与只读实例属性一样，可以直接将原本应该写在get代码块中的代码写在subscript中即可：
+subscript(index: Int) -> Int {
+ // 返回与入参匹配的Int类型的值
+}
+下面代码演示了一个在TimesTable结构体中使用只读下标的用法，该结构体用来展示传入整数的N倍。
+struct TimesTable {
+ let multiplier: Int
+ subscript(index: Int) -> Int {
+ return multiplier * index
+ }
+}
+let threeTimesTable = TimesTable(multiplier: 3)
+println("3的6倍是\(threeTimesTable[6])")
+// 输出 "3的6倍是18"
+在上例中，通过TimesTable结构体创建了一个用来表示索引值三倍的实例。数值3作为结构体构造函数入参表示这个值将成为实例成员multiplier的值。
+你可以通过下标来来得到结果，比如threeTimesTable[6]。这句话访问了threeTimesTable的第六个元素，返回18或者6的3倍。
++提示
+TimesTable例子是基于一个固定的数学公式。它并不适合开放写权限来对threeTimesTable[someIndex]进行赋值操作，这也是为什么下标只定义为只读的原因。
+
下标根据使用场景不同也具有不同的含义。通常下标是用来访问集合(collection)，列表(list)或序列(sequence)中元素的快捷方式。你可以为特定的类或结构体中自由的实现下标来提供合适的功能。
+例如，Swift的字典(Dictionary)实现了通过下标来对其实例中存放的值进行存取操作。在字典中设值可以通过给字典提供一个符合字典索引类型的索引值的表达式赋一个与字典存放值类型匹配的值来做到：
+var numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
+numberOfLegs["bird"] = 2
+上例定义一个名为numberOfLegs的变量并用一个字典表达式初始化出了包含三对键值的字典实例。numberOfLegs的字典存放值类型推断为Dictionary<String, Int>。字典实例创建完成之后通过下标的方式将整型值2赋值到字典实例的索引为bird的位置中。
更多关于字典(Dictionary)下标的信息请参考字典的访问与修改
+++提示
+Swift中Dictionary的下标实现中，在get部分返回值是
+Int?，也就是说不是每个字典的索引都能得到一个整型值，对于没有设过值的索引的访问返回的结果就是nil；同样想要从字典实例中删除某个索引下的值也只需要给这个索引赋值为nil即可。
下标允许任意数量的入参索引，并且每个入参类型也没有限制。下标的返回值也可以是任何类型。下标可以使用变量参数和可变参数，但使用in-out参数或给参数设置默认值都是不允许的。
+一个类或结构体可以根据自身需要提供多个下标实现，在定义下标时通过入参个类型进行区分，使用下标时会自动匹配合适的下标实现运行，这就是下标的重载。
+一个下标入参是最常见的情况，但只要有合适的场景也可以定义多个下标入参。如下例定义了一个Matrix结构体，将呈现一个Double类型的二维数组。Matrix结构体的下标需要两个整型参数：
+struct Matrix {
+ let rows: Int, columns: Int
+ var grid: Double[]
+ init(rows: Int, columns: Int) {
+ self.rows = rows
+ self.columns = columns
+ grid = Array(count: rows * columns, repeatedValue: 0.0)
+ }
+ func indexIsValidForRow(row: Int, column: Int) -> Bool {
+ return row >= 0 && row < rows && column >= 0 && column < columns
+ }
+ subscript(row: Int, column: Int) -> Double {
+ get {
+ assert(indexIsValidForRow(row, column: column), "Index out of range")
+ return grid[(row * columns) + column]
+ }
+ set {
+ assert(indexIsValidForRow(row, column: column), "Index out of range")
+ grid[(row * columns) + columns] = newValue
+ }
+ }
+}
+Matrix提供了一个两个入参的构造方法，入参分别是rows和columns，创建了一个足够容纳rows * columns个数的Double类型数组。为了存储，将数组的大小和数组每个元素初始值0.0，都传入数组的构造方法中来创建一个正确大小的新数组。关于数组的构造方法和析构方法请参考Creating and Initializing an Array。
你可以通过传入合适的row和column的数量来构造一个新的Matrix实例：
+var matrix = Matrix(rows: 2, columns: 2)
+上例中创建了一个新的两行两列的Matrix实例。在阅读顺序从左上到右下的Matrix实例中的数组实例grid是矩阵二维数组的扁平化存储：
+// 示意图
+grid = [0.0, 0.0, 0.0, 0.0]
+
+ col0 col1
+row0 [0.0, 0.0,
+row1 0.0, 0.0]
+将值赋给带有row和column下标的matrix实例表达式可以完成赋值操作，下标入参使用逗号分割
+matrix[0, 1] = 1.5
+matrix[1, 0] = 3.2
+上面两句话分别让matrix的右上值为1.5，坐下值为3.2：
+[0.0, 1.5,
+ 3.2, 0.0]
+Matrix下标的getter和setter中同时调用了下标入参的row和column是否有效的判断。为了方便进行断言，Matrix包含了一个名为indexIsValid的成员方法，用来确认入参的row或column值是否会造成数组越界：
+func indexIsValidForRow(row: Int, column: Int) -> Bool {
+ return row >= 0 && row < rows && column >= 0 && column < columns
+}
+断言在下标越界时触发：
+let someValue = matrix[2, 2]
+// 断言将会触发，因为 [2, 2] 已经超过了matrix的最大长度
+++ + +译者：这里有个词Computed Properties 这里统一翻译为实例属性了 微软术语引擎里没有这个词
+
一个类可以继承另一个类的方法，属性和其它特性。当一个类继承其它类，继承类叫子类，被继承类叫超类（或父类）。在Swift中，继承是区分「类」与其它类型的一个基本特征。
diff --git a/chapter2/14_Initialization.html b/chapter2/14_Initialization.html index 56941db9..939501c0 100644 --- a/chapter2/14_Initialization.html +++ b/chapter2/14_Initialization.html @@ -46,7 +46,7 @@ -在一个类的实例被释放之前，析构函数被立即调用。用关键字deinit来标示析构函数，类似于初始化函数用init来标示。析构函数只适用于类类型。
diff --git a/chapter2/16_Automatic_Reference_Counting.html b/chapter2/16_Automatic_Reference_Counting.html index cd0228d5..237b734f 100644 --- a/chapter2/16_Automatic_Reference_Counting.html +++ b/chapter2/16_Automatic_Reference_Counting.html @@ -46,7 +46,7 @@ -本页包含内容：
diff --git a/chapter2/17_Optional_Chaining.html b/chapter2/17_Optional_Chaining.html index 676c4369..403d7630 100644 --- a/chapter2/17_Optional_Chaining.html +++ b/chapter2/17_Optional_Chaining.html @@ -46,7 +46,7 @@ -可选链（Optional Chaining）是一种可以请求和调用属性、方法及子脚本的过程，它的自判断性体现于请求或调用的目标当前可能为空（nil）。如果自判断的目标有值，那么调用就会成功；相反，如果选择的目标为空（nil），则这种调用将返回空（nil）。多次请求或调用可以被链接在一起形成一个链，如果任何一个节点为空（nil）将导致整个链失效。
（ps：为了方便各位检验所以保留了英文，可删。） diff --git a/chapter2/19_Nested_Types.html b/chapter2/19_Nested_Types.html index ce76da49..f0989cf9 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 ef0e15d7..e5584f03 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 479fd3e6..54549200 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 c582e867..b0e443e8 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 51a0b00d..7ecc4425 100644 --- a/manifest.appcache +++ b/manifest.appcache @@ -1,5 +1,5 @@ CACHE MANIFEST -# Revision 1402238318317 +# Revision 1402267410055 CACHE: index.html @@ -15,8 +15,8 @@ chapter2/06_Functions.html chapter2/07_Closures.html chapter2/08_Enumerations.html chapter2/09_Classes_and_Structures.html -chapter2/11_Methods.html chapter2/10_Properties.html +chapter2/11_Methods.html chapter2/12_Subscripts.html chapter2/02_Basic_Operators.html chapter2/14_Initialization.html diff --git a/search_index.json b/search_index.json index 3917729e..9f296e86 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_4":["2014","issu","languag","program","pull","qq群：364279588","request","swift","undefinedundefin","wwdc"],"chapter1/01_swift.html#gitbook_5":["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_6":["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