快看Sample代碼，速學Swift語言（1）-語法速覽

Swift是蘋果推出的一個比較新的語言，它除了借鑒語言如C#、Java等內容外，好像還採用了很多JavaScript腳本裡面的一些腳本語法，用起來感覺非常棒，作為一個使用C#多年的技術控，對這種比較超前的語言非常感興趣，之前也在學習ES6語法的時候學習了阮一峰的《ECMAScript 6 入門》，對... ...

Swift是蘋果推出的一個比較新的語言，它除了借鑒語言如C#、Java等內容外，好像還採用了很多JavaScript腳本裡面的一些腳本語法，用起來感覺非常棒，作為一個使用C#多年的技術控，對這種比較超前的語言非常感興趣，之前也在學習ES6語法的時候學習了阮一峰的《ECMAScript 6 入門》，對JavaScript腳本的ES6語法寫法嘆為觀止，這種Swift語言也具有很多這種腳本語法的特點，可以說這個Swift在吸收了Object C的優點並摒棄一些不好的東西外，同時吸收了大量新一代語言的各種特點，包括泛型、元祖等特點。我在學習Swift的時候，發現官方的語言介紹文章（The Swift Programming Language）還是非常淺顯易懂，雖然是英文，不過代碼及分析說明都很到位，就是內容顯得比較多一些，而我們作為技術人員，一般看代碼就很好瞭解了各種語法特點了，基於這個原因，我對官網的案例代碼進行了一個摘要總結，以代碼的方式進行Swift語言的語法特點介紹，總結一句話就是：快看Sample代碼，速學Swift語言。

1、語法速覽

var myVariable = 42
myVariable = 50
let myConstant = 42

變數定義用var，常量則用let，類型自行推斷。

let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."

用括弧包含變數

let quotation = """
I said "I have \(apples) apples."
And then I said "I have \(apples + oranges) pieces of fruit."
"""

代碼通過三個雙引號來包含預定格式的字元串（包括換行符號），左側縮進空格省略。

var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"
 
var occupations = [
    "Malcolm": "Captain",
    "Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"

數組和字典集合初始化符合常規，字典後面可以保留逗號結尾

let emptyArray = [String]()
let emptyDictionary = [String: Float]()

初始化函數也比較簡潔。

let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
    if score > 50 {
        teamScore += 3
    } else {
        teamScore += 1
    }
}
print(teamScore)

控制流的if-else這些和其他語言沒有什麼差異，for ... in 則是迭代遍歷的語法，控制流方式還支持其他的while、repeat...while等不同的語法。

var optionalString: String? = "Hello"
print(optionalString == nil)
 
var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
    greeting = "Hello, \(name)"
}

這部分則是可空類型的使用，以及可空判斷語句的使用，可空判斷語句在Swift中使用非常廣泛，這種相當於先求值再判斷是否進入大括符語句。

let vegetable = "red pepper"
switch vegetable {
case "celery":
    print("Add some raisins and make ants on a log.")
case "cucumber", "watercress":
    print("That would make a good tea sandwich.")
case let x where x.hasSuffix("pepper"):
    print("Is it a spicy \(x)?")
default:
    print("Everything tastes good in soup.")
}

Switch語法和常規的語言不同，這種簡化了一些語法，每個子條件不用顯式的寫break語句（預設就是返回的），多個條件逗號分開即可公用一個判斷處理。

let interestingNumbers = [
    "Prime": [2, 3, 5, 7, 11, 13],
    "Fibonacci": [1, 1, 2, 3, 5, 8],
    "Square": [1, 4, 9, 16, 25],
]
var largest = 0
for (kind, numbers) in interestingNumbers {
    for number in numbers {
        if number > largest {
            largest = number
        }
    }
}
print(largest)

上面字典遍歷的方式採用for...in的方式進行遍歷，另外通過(kind, numbers)的方式進行一個參數的解構過程，把字典的鍵值分別付給kind，numbers這兩個參數。

var total = 0
for i in 0..<4 {
    total += i
}
print(total)

上面的for...in迴圈採用了一個語法符號..<屬於數學半封閉概念，從0到4，不含4，同理還有全封閉符號：...全包含左右兩個範圍的值。

func greet(person: String, day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet(person: "Bob", day: "Tuesday")

上面是函數的定義，以func關鍵字定義，括弧內是參數的標簽、名稱和類型內容，返回值通過->指定。

上面函數需要輸入參數名稱，如果不需要參數名稱，可以通過下劃線省略輸入，如下

func greet(_ person: String, on day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")

另外參數名稱可以使用標簽名稱。

func greet(person: String, from hometown: String) -> String {
    return "Hello \(person)!  Glad you could visit from \(hometown)."
}
print(greet(person: "Bill", from: "Cupertino"))
// Prints "Hello Bill!  Glad you could visit from Cupertino."

嵌套函數如下所示。

func returnFifteen() -> Int {
    var y = 10
    func add() {
        y += 5
    }
    add()
    return y
}
returnFifteen()

複雜一點的函數的參數可以傳入函數進行使用，這種類似閉包的處理了

func hasAnyMatches(list: [Int], condition: (Int) -> Bool) -> Bool {
    for item in list {
        if condition(item) {
            return true
        }
    }
    return false
}
func lessThanTen(number: Int) -> Bool {
    return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(list: numbers, condition: lessThanTen)

下麵是一個閉包的函數，閉包通過in 來區分參數和返回的函數體

numbers.map({ (number: Int) -> Int in
    let result = 3 * number
    return result
})

class Shape {
    var numberOfSides = 0
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

類的定義通過class關鍵字進行標識，預設的許可權是internal，在項目模塊內部可以訪問的，非常方便。

使用則如下所示，可以通過點語法直接獲取屬性和調用方法。

var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()

class NamedShape {
    var numberOfSides: Int = 0
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

類通過使用init的指定名稱作為構造函數，使用deinit來做析構函數，使用self來獲取當前的類引用，類似於其他語言的this語法，super獲取基類的引用。

其他的處理方式如繼承、重寫的語法和C#類似。

class Square: NamedShape {
    var sideLength: Double
    
    init(sideLength: Double, name: String) {
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 4
    }
    
    func area() -> Double {
        return sideLength * sideLength
    }
    
    override func simpleDescription() -> String {
        return "A square with sides of length \(sideLength)."
    }
}
let test = Square(sideLength: 5.2, name: "my test square")
test.area()
test.simpleDescription()

類的屬性使用get、set語法關鍵字，和C#類似

class EquilateralTriangle: NamedShape {
    var sideLength: Double = 0.0
    
    init(sideLength: Double, name: String) {
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 3
    }
    
    var perimeter: Double {
        get {
            return 3.0 * sideLength
        }
        set {
            sideLength = newValue / 3.0
        }
    }

class TriangleAndSquare {
    var triangle: EquilateralTriangle {
        willSet {
            square.sideLength = newValue.sideLength
        }
    }
    var square: Square {
        willSet {
            triangle.sideLength = newValue.sideLength
        }
    }

類屬性的賦值可以進行觀察，如通過willSet在設置之前調用，didSet在設置之後調用，實現對屬性值得監控處理。

enum Rank: Int {
    case ace = 1
    case two, three, four, five, six, seven, eight, nine, ten
    case jack, queen, king
    func simpleDescription() -> String {
        switch self {
        case .ace:
            return "ace"
        case .jack:
            return "jack"
        case .queen:
            return "queen"
        case .king:
            return "king"
        default:
            return String(self.rawValue)
        }
    }
}
let ace = Rank.ace
let aceRawValue = ace.rawValue

和類及其他類型一樣，枚舉類型在Swift中還可以有方法定義，是一種非常靈活的類型定義，這個和我們之前接觸過的一般語言有所差異。

enum ServerResponse {
    case result(String, String)
    case failure(String)
}
 
let success = ServerResponse.result("6:00 am", "8:09 pm")
let failure = ServerResponse.failure("Out of cheese.")
 
switch success {
case let .result(sunrise, sunset):
    print("Sunrise is at \(sunrise) and sunset is at \(sunset).")
case let .failure(message):
    print("Failure...  \(message)")
}

struct Card {
    var rank: Rank
    var suit: Suit
    func simpleDescription() -> String {
        return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"
    }
}
let threeOfSpades = Card(rank: .three, suit: .spades)
let threeOfSpadesDescription = threeOfSpades.simpleDescription()

結構類型和類的各個方面很類似，結構支持構造函數，方法定義，屬性等，重要一點不同是結構在代碼傳遞的是副本，而類實例傳遞的是類的引用。

protocol ExampleProtocol {
    var simpleDescription: String { get }
    mutating func adjust()
}

這裡的協議，類似很多語言的介面概念，不過比常規語言（包括C#）的介面更加多樣化、複雜化一些。

Swift的協議，可以有部分方法實現，協議可以可選，繼承其他協議等等。

extension Int: ExampleProtocol {
    var simpleDescription: String {
        return "The number \(self)"
    }
    mutating func adjust() {
        self += 42
    }
}
print(7.simpleDescription)

擴展函數通過extension進行標識，可以為已有的類進行擴展一些特殊的方法處理，這個類似C#的擴展函數。

func send(job: Int, toPrinter printerName: String) throws -> String {
    if printerName == "Never Has Toner" {
        throw PrinterError.noToner
    }
    return "Job sent"
}

異常處理中，函數聲明通過throws關鍵字標識有異常拋出，在函數裡面通過throw進行異常拋出處理。

而在處理有異常的地方進行攔截，則通過do...catch的方式進行處理，在do的語句裡面，通過try來攔截可能出現的異常，預設catch裡面的異常名稱為error。

do {
    let printerResponse = try send(job: 1040, toPrinter: "Bi Sheng")
    print(printerResponse)
} catch {
    print(error)
}

可以對多個異常進行判斷處理

do {
    let printerResponse = try send(job: 1440, toPrinter: "Gutenberg")
    print(printerResponse)
} catch PrinterError.onFire {
    print("I'll just put this over here, with the rest of the fire.")
} catch let printerError as PrinterError {
    print("Printer error: \(printerError).")
} catch {
    print(error)
}

還可以通過使用try?的方式進行友好的異常處理，如果有異常返回nil，否者獲取結果賦值給變數

let printerSuccess = try? send(job: 1884, toPrinter: "Mergenthaler")
let printerFailure = try? send(job: 1885, toPrinter: "Never Has Toner")

var fridgeIsOpen = false
let fridgeContent = ["milk", "eggs", "leftovers"]
 
func fridgeContains(_ food: String) -> Bool {
    fridgeIsOpen = true
    defer {
        fridgeIsOpen = false
    }
    
    let result = fridgeContent.contains(food)
    return result
}
fridgeContains("banana")
print(fridgeIsOpen)

使用defer的關鍵字來在函數返回前處理代碼塊，如果有多個defer函數，則是後進先出的方式進行調用，最後的defer先調用，依次倒序。

func makeArray<Item>(repeating item: Item, numberOfTimes: Int) -> [Item] {
    var result = [Item]()
    for _ in 0..<numberOfTimes {
        result.append(item)
    }
    return result
}
makeArray(repeating: "knock", numberOfTimes: 4)

Swift支持泛型，因此可以大大簡化很多函數的編寫，提供更加強大的功能。

enum OptionalValue<Wrapped> {
    case none
    case some(Wrapped)
}
var possibleInteger: OptionalValue<Int> = .none
possibleInteger = .some(100)

func anyCommonElements<T: Sequence, U: Sequence>(_ lhs: T, _ rhs: U) -> Bool
    where T.Iterator.Element: Equatable, T.Iterator.Element == U.Iterator.Element {
        for lhsItem in lhs {
            for rhsItem in rhs {
                if lhsItem == rhsItem {
                    return true
                }
            }
        }
        return false
}
anyCommonElements([1, 2, 3], [3])

泛型的參數支持where的關鍵字進行泛型類型的約束，如可以指定泛型的參數採用什麼協議或者繼承哪個基類等等。