從Objective-C到Swift——Swift糖果
Swift帶來很多確實很棒的特性，使得很難再回到Objective-C。主要的特性是安全性，不過這也被看成是一種額外副作用。
帶類型接口的強型別
Swift有強型別，這意味著除非你要求，不然Swift不會為你做類型之間的轉換。所以，例如你無法把Int型賦給Double型。你不得不首先轉換類型：
- let i: Int = 42
- let d: Double = Double(i)
或者你必須給Double類擴展一個方法用來轉換Int型：
- extension Double {
- func __convert(i: Int) -> Double {
- return Double(i)
- }
- }
- let another_d: Double = i
強型別對于安全性是非常非常有利的。但是，如果它沒有為你給類型接口添加許多類型信息的話，它也可能變成有一點令人生畏的事情，有點像是在寫腳本語言。
- let ary = ["Hello", "world"] // NOTE: 'ary' is of type String[] or Array<String>
- for s in ary { // NOTE: 's' is of type String
- print(s + " ")
- }
如果你想要創建一個包含很多類型(無共同祖先)的數組，你應該用枚舉(它可以包含值，見如下)。如果你想要它能夠包含所有值，你可以用Any型。如果想讓它包含任何Objective-C的類型，那就用AnyObject型。
請注意類型接口不會在申明函數的時候為你添加類型。你必須明確地說明你所申明函數的類型。
Blocks
Swift 中的Blocks很像Objective-C中的Blocks, 不過有兩點不同: 類型推斷和避免weakify dance.
對于類型推斷，你不必每次寫block時都包含完整類型信息：
- sort([2,1,3], {
- (a: Int, b: Int) -> Bool in return a < b
- })
- // Using Type Inference
- // Using the Trailing Closures feature
- sort([2,1,3]) {
- a, b in return a < b
- }
- // Implicit 'return' for single-expression blocks
- sort([2,1,3]) { a,b in a<b }
- // Shorthand Argument Names
- sort([2,1,3]) { $0 < $1 }
- // Operators are functions, and functions are blocks too!
- let sorted: Int[] = sort([2,1,3], <)
訪問 Closures 了解更多blocks信息。
除此之外，Objectvie-C 的weakify dance有點容易，只需在block的開始處加上 [unowned self] 或 [weak self] 即可。
- class CallbackTest {
- var i = 5
- var callback: (Int -> ())? // NOTE: The optional callback takes an Int
- deinit { // NOTE: This is like -dealloc in Objective-C
- println("Deinit")
- }
- }
- var obj = CallbackTest()
- obj.callback = {
- [unowned obj] // NOTE: Without this, deinit() would never be invoked!
- a in
- obj.i = a
- }
請注意Introduction post文章中介紹了Optional（像上面的callback）。
請參考 ARC 章節來了解更多關于Swift中ARC的信息。
強勁的Enumerations
Swift中的枚舉比Objective-C中的有很大提高。
修復 Enums
Apple一直提倡顯示的提供枚舉類型的大小，不過被Objective-C搞亂了:
- // Apple recommended enum definition in Objective-C
- typedef NS_ENUM(NSInteger, UIViewAnimationCurve) {
- UIViewAnimationCurveEaseInOut,
- UIViewAnimationCurveEaseIn,
- UIViewAnimationCurveEaseOut,
- UIViewAnimationCurveLinear
- };
- // Previous Apple recommended enum definition in Objective-C. No link between
- // enum values and theUIViewAnimationCurve type.
- typedef enum {
- UIViewAnimationCurveEaseInOut,
- UIViewAnimationCurveEaseIn,
- UIViewAnimationCurveEaseOut,
- UIViewAnimationCurveLinear
- };
- typedef NSInteger UIViewAnimationCurve;
- // Traditional enum definition in Objective-C. No explicit fixed size.
- typedef enum {
- UIViewAnimationCurveEaseInOut,
- UIViewAnimationCurveEaseIn,
- UIViewAnimationCurveEaseOut,
- UIViewAnimationCurveLinear
- } UIViewAnimationCurve;
Swift中的修復：
- enum UIViewAnimationCurve : Int {
- case EaseInOut
- case EaseIn
- case EaseOut
- case Linear
- }
拓展Enums
Enums 在Swift中更進一步，只作為一個獨立的選項列表。你可以添加方法（以及計算屬性）:
- enum UIViewAnimationCurve : Int {
- case EaseInOut
- case EaseIn
- case EaseOut
- case Linear
- func typeName() -> String {
- return "UIViewAnimationCurve"
- }
- }
使用類型拓展，你可以向枚舉中添加任何你想要的方法：
- extension UIViewAnimationCurve {
- func description() -> String {
- switch self {
- case EaseInOut:
- return "EaseInOut"
- case EaseIn:
- return "EaseIn"
- case EaseOut:
- return "EaseOut"
- case Linear:
- return "Linear"
- }
- }
- }
#p#
向Enums中添加值
Swift中的枚舉跟進一步，允許每一個獨立的選項都有一個對應的值：
- enum Shape {
- case Dot
- case Circle(radius: Double) // Require argument name!
- case Square(Double)
- case Rectangle(width: Double, height: Double) // Require argument names!
- func area() -> Double {
- switch self {
- case Dot:
- return 0
- case Circle(let r): // Assign the associated value to the constant 'r'
- return π*r*r
- case Square(let l):
- return l*l
- case Rectangle(let w, let h):
- return w*h
- }
- }
- }
- var shape = Shape.Dot
- shape = .Square(2)
- shape = .Rectangle(width: 3, height: 4) // Argument names required
- shape.area()
如果你喜歡，你可以把它當做一個安全的union類型。或者只用枚舉應該做的事情。
Enumerations 文章介紹了更多關于Apple對此的看法。
Swift Switch語句
就像你看到的，Swift中switch語句有很多優化。
隱式的fall-through行為已經改為了顯示的:
- var (i, j) = (4, -1) // Assign (and create) two variables simultaneously
- switch i {
- case 1:
- j = 1
- case 2, 3: // The case for both 2 and 3
- j = 2
- case 4:
- j = 4
- fallthrough
- case 5:
- j++
- default:
- j = Int.max // The Swift version of INT_MAX
- }
就像前面看到的，Switch 語句可以訪問枚舉的關聯值，不過它還可以做更多：
- var tuple: (Int, Int) // Did I mention that Swift has tuples? :-)
- var result: String
- tuple = (1,3)
- switch tuple {
- case (let x, let y) where x > y:
- result = "Larger"
- case (let x, let y) where x < y:
- result = "Smaller"
- default:
- result = "Same"
- }
甚至可以使用String：
- var s: String = "Cocoa"
- switch s {
- case "Java": s = "High caffeine"
- case "Cocoa": s = "High sugar"
- case "Carbon": s = "Lots of bubbles"
- default: ()
- }
另外，如果你覺得他可以使你的代碼更可讀，你可以重載~=操作符來改變switch語句的行為。
- func ~=(pattern: String, str: String) -> Bool {
- return str.hasPrefix(pattern)
- }
- var s = "Carbon"
- switch s {
- case "J": s = "High caffeine"
- case "C": s = "No caffeine"
- default: ()
- }
你可以從 Conditional Statements 這篇文章中了解更多關于switch語句的知識。
類與結構體
類似于C++，Swift的類與結構體初看是一樣的:
- class Apple {
- var color = "green" // Property declaration
- init() {} // Default initializer
- init(_ color: String) { // '_' means no argument name
- self.color = color
- }
- func description() -> String {
- return "apple of color \(color)"
- }
- func enripen() {
- color = "red"
- }
- }
- struct Orange {
- var color = "green"
- init() {}
- init(_ color: String) {
- self.color = color
- }
- func description() -> String {
- return "orange of color \(color)"
- }
- mutating func enripen() { // NOTE: 'mutating' is required
- color = "orange"
- }
- }
- var apple1 = Apple()
- var apple2 = apple1 // NOTE: This references the same object!
- apple1.enripen()
- apple2.description() // Result: "apple of color red"
- var orange1 = Orange()
- var orange2 = orange1 // NOTE: This makes a copy!
- orange1.enripen()
- orange2.description() // Result: "orange of color green"
主要的不同點在于類是(和塊相似的)引用類型，而結構體是（和枚舉相似的)數值類型。所以兩個變量能夠指向同一個(類的)對象，而把一個結構體賦給 另外一個變量則必須做一個此結構體的(緩慢的)拷貝。關鍵詞'mutating'告訴調用者enripen()方法不能被常結構體調用。把一個常引用 mutating給一個類對象則沒有問題。
Swift中大多數內建類型實際上都是結構體。甚至Int型也是。通過點擊Cmd你能夠看到內建類型的申明，比如Int型的Swift(或者 Playground)源碼。數組和詞典類型也是結構體，但是數組在某些方面表現得像是引用類型:賦值數組并不拷貝每一個元素，實際上你可以更新常數組只 要元素的個數保持不變。
- let array1 = [1, 2, 3]
- let array2 = array1 // A copy, but references the same elements!
- array1[1] = 5 // Legal, as it doesn't modify the struct but a referenced element
- array2 // Result: [1, 5, 3]
在蘋果的文檔中，你可以讀到更多關于Collection Types的內容。
#p#
對象的生命周期
另一個類與結構體的不同是類可以被子類化。 雷和結構體都可以被拓展，并且實現protocol，但是只用類可以繼承其他類。
- class Pineapple : Apple {
- init(color: String) {
- super.init(color)
- }
- convenience init() {
- self.init("green")
- }
- convenience init(ripe: Bool) {
- self.init()
- if ripe {
- color = "yellow"
- } else {
- color = "green"
- }
- }
- deinit {
- println("Pineapple down")
- }
- override func description() -> String {
- return "pine" + super.description()
- }
- override func enripen() {
- color = "yellow"
- }
- }
就像你看到的，Swift為繼承添加了一點更有趣的需要學習的東西。對于初學者來說，你需要清除你覆蓋父類中某個方法的意圖。如果你想阻止子類覆蓋一些東西，你可以在一個單獨聲明或整個類的前面加上@final屬性。閱讀 Apple’s documentation了解更多。
初始化
Swift的對象分兩步進行初始化: 首先對象必須是有效的，然后它能被替換。
- class ChildShoe {
- var size: Double // Uninitialized properties are not allowed unless taken care of in init()
- init(foot_size: Double) {
- size = foot_size // First make the object valid
- addGrowthCompensation()
- }
- func addGrowthCompensation() {
- size++
- }
- }
使對象有效必須要調用一個超級類指定的init()方法。類可以同時擁有指定的以及便捷的(用關鍵詞'convenience'標記)初始化方法。 便捷初始化方法調用同一個類中的其他初始化方法(最終還是一個指定的初始化方法)，而指定的初始化方法調用超級類的初始化方法。
如果你給所有的超級類指定初始化方法添加初始化方法，你的類也會自動繼承所有便捷初始化方法。如果沒有添加任何指定的初始化方法，你的類則繼承超級類的所有(指定的和便捷的)初始化方法。
深入閱讀請參見Initialization。
類型轉換
類之間的轉換，特別是向下轉換，你可以使用"is","as?"和"as"關鍵詞:
- let apple: Apple = Pineapple()
- let exotic: Bool = apple is Pineapple
- let pineappleOption: Pineapple? = apple as? Pineapple
- let pineapple: Pineapple = apple as Pineapple // NOTE: Throws if not!
- if let obj = apple as? Pineapple { // If executed, 'obj' is a Pineapple
- "sweet"
- }
想了解更多這方面內容請參見Type Casting一章.
泛型
泛型是Swift的一個加分的特點。他們看起來有一點像C++里面的模板，但是有更強的型別，也更簡單(更簡單使用，功能稍遜)。
- 01 // Mark both Int and Double as being convertible to a Double using the '+' prefix
- 02 protocol DoubleConvertible {
- 03 @prefix func +(v: Self) -> Double
- 04 }
- 05 @prefix func +(v: Int) -> Double { return Double(v) }
- 06 extension Double: DoubleConvertible {}
- 07 extension Int: DoubleConvertible {}
- 08 // NOTE: Repeat this for all Int*, UInt*, and the Float type
- 09
- 10 // The traits of a generalized point
- 11 protocol PointTraits {
- 12 typealias T
- 13 class var dimensions: Int { get }
- 14 func getCoordinate(dimension: Int) -> T
- 15 }
- 16
- 17 // Generalized Pythagoras
- 18 struct Pythagoras<P1: PointTraits, P2: PointTraits where P1.T: DoubleConvertible, P2.T: DoubleConvertible> {
- 19 static func apply(a: P1, b: P2, dimensions: Int) -> Double {
- 20 if dimensions == 0 {
- 21 return 0
- 22 }
- 23 let d: Double = +a.getCoordinate(dimensions-1) - +b.getCoordinate(dimensions-1) // NOTE: '+' to convert to Double
- 24 return d * d + apply(a, b: b, dimensions: dimensions-1)
- 25 }
- 26 static func apply(a: P1, b: P2) -> Double {
- 27 let dimensions = P1.dimensions
- 28 assert(P2.dimensions == dimensions)
- 29 return apply(a, b: b, dimensions: dimensions)
- 30 }
- 31 };
- 32
- 33 import func Foundation.sqrt // NOTE: You can import a typealias­, struct­, class­, enum­, protocol­, var­, or func only
- 34
- 35 func distance<P1: PointTraits, P2: PointTraits where P1.T: DoubleConvertible, P2.T: DoubleConvertible>(a: P1, b: P2) -> Double {
- 36 assert(P1.dimensions == P2.dimensions)
- 37 return sqrt(Pythagoras.apply(a, b: b));
- 38 }
- 39
- 40 // A generalized 2D point
- 41 struct Point2D<Number> : PointTraits {
- 42 static var dimensions: Int { return 2 }
- 43 var x: Number, y: Number
- 44 func getCoordinate(dimension: Int) -> Number { return dimension == 0 ? x : y } // NOTE: The typealias T is inferred
- 45 }
- 46 let a = Point2D(x: 1.0, y: 2.0)
- 47 let b = Point2D(x: 5, y: 5)
- 48 Pythagoras.apply(a, b: b) // NOTE: Methods require all argument names, except the first
- 49 distance(a, b) // NOTE: Functions do not require argument names
- 50
- 51 // UIColor
- 52 extension UIColor : PointTraits {
- 53 class var dimensions: Int { return 4 }
- 54 func getCoordinate(dimension: Int) -> Double {
- 55 var red: CGFloat = 0, green: CGFloat = 0, blue: CGFloat = 0, alpha: CGFloat = 0
- 56 getRed(&red, green: &green, blue: &blue, alpha: &alpha)
- 57 switch dimension {
- 58 case 0: return red
- 59 case 1: return green
- 60 case 2: return blue
- 61 default: return alpha
- 62 }
- 63 }
- 64 }
- 65 distance(UIColor.redColor(), UIColor.orangeColor())
以上代碼是受Boost中的Design Rationale的啟發.幾何的C++庫。Swift中的泛型功能不是那么強，但是卻能使源碼比C++中泛型更具閱讀性。
Swift的泛型是通過類型參數化的。每個參數類型要求實現一個特定的協議或者繼承自一個特定的基類。在申明參數類型后，有一個可選 的"where"項目能用于給這個類型(或者是他們的內部類型，就如上面那個PointTraits協議中的別名'T')添加額外的需求。這 個"where“也能要求兩種類型是相等的。
蘋果有更多更完整的Generics章節。
選定Swift
現在你已經準備好了去看各種各樣的源碼了，甚至可以自己寫了 :-)
在把你自己留在一個新的大的Swift未知大陸之前，我有幾個最終的建議:
-
Apple推薦你使用Int作為所有Integer類型，即使你之前用無符號數的地方。“只有在你真的需要一個與平臺原生大小想相同的無符號integer類型時再使用UInt類型.”
-
如果你想知道@private和al.在哪：好吧，他們還沒完成呢，后續版本會加進來的。
-
如果你創建了一個module，你可以Cmd+單擊你的module的名字來查看你的module的自動生成的Swift頭。
-
Swift的modules其實是命名空間，因此在任何東西前加像 CF, NS, UI等的前綴。當創建第三方庫是就不是那么絕對必要了。
Enjoy using Swift!
