Swift语法新手快速入门

编程语言教程中的第一个程序应该在屏幕上打印“Hello, world”。在Swift中，可以用一行代码实现：

print("Hello, world!")

如果你写过C或者Objective-C代码，那你应该很熟悉这种形式。在Swift中，这行代码就是一个完整的程序。你不需要为了输入输出或者字符串处理导入一个单独的库。全局作用域中的代码会被自动当做程序的入口点，所以你也不需要main()函数。你同样不需要在每个语句结尾写上分号。

这个教程会通过一系列编程例子来让你对Swift有初步了解，如果你有什么不理解的地方也不用担心，任何本章介绍的内容都会在后面的章节中详细讲解。

数据类型

在Swift中，类型分为两类：值类型和引用类型。

值类型存放在栈区，每个实例持有数据的副本，并且该副本对于每个实例来说是独一无二的一份。结构体（struct）、枚举（enum）、元组（tuple）都是值类型。常用的值类型如Int、Double、Float、String、Array、Dictionary、Set等，其实都是用结构体实现的。

• Int类型：用于表示整数，包括正整数和负整数。

  let age: Int = 30
  let numberOfStudents = 50
  

• Double和Float类型：用于表示浮点数，即带有小数点的数值。Double提供更高的精度，而Float提供较低的精度。默认推断为Double类型。

  let pi: Double = 3.14159
  let percentage: Float = 0.75
  

• String类型：用于表示文本字符串。

  let message: String = "Hello, World!"
  let name = "John Doe"
  

• Bool类型：用于表示布尔值，只有两个可能的值：true和false。

  let isLoggedin: Bool = true
  let isAdmin = false
  

• Array类型：用于表示有序列表，可以包含相同或不同类型的元素。

  let numbers: [Int] = [1, 2, 3, 4, 5]
  let names = ["John", "Jane", "Tom"]
  

• Dictionary类型：用于表示无序的键值对集合，其中每个元素都有一个唯一的键和对应的值。

  let person: [String: Any] = ["name": "John", "age": 30, "isMarried": false]
  let scores = ["Math": 90, "English": 85, "Science": 95]
  

• Set类型：用于表示无序且唯一的值的集合。

  let uniqueNumbers: Set<Int> = [1, 2, 3, 4, 5]
  let vowels: Set<Character> = ["a", "e", "i", "o", "u"]
  

• Tuple类型：用于创建包含多个不同类型的值的复合数据类型。

  let coordinates: (Double, Double) = (37.7749, -122.4194)
  let personInfo = ("John", 30, true)
  

Swift为不确定类型提供了两种特殊的类型别名：Any和AnyObject。Any可以表示任何类型，包括函数类型；AnyObject可以表示任何类类型的实例。例如：

var things: [Any] = []
things.append(0)
things.append(0.0)
things.append(42)
things.append(3.14159)
things.append("hello")
things.append((3.0, 5.0))
things.append(Movie(name: "Ghostbusters", director: "Ivan Reitman"))
things.append({ (name: String) -> String in "Hello, \(name)" })

你可以在switch表达式的case中使用is和as操作符来找出只知道是Any或AnyObject类型的常量或变量的具体类型。

引用类型存放在堆区，实例共享数据唯一的一份副本。类（class）和闭包就是引用类型。

简单值

使用let来声明常量，使用var来声明变量。一个常量的值在编译时并不需要有明确的值，但是你只能为它赋值一次。这说明你可以用一个常量来命名一个值，一次赋值就可在多个地方使用。

var myVariable = 42
myVariable = 50
let myConstant = 42

常量或者变量的类型必须和你赋给它们的值一样。然而，你不用明确地声明类型。当你通过一个值来声明变量和常量时，编译器会自动推断其类型。

如果初始值没有提供足够的信息（或者没有初始值），那你需要在变量后面声明类型，用冒号分割。

let implicitInteger = 70
let implicitDouble = 70.0
let explicitDouble: Double = 70

值永远不会被隐式转换为其他类型。如果你需要把一个值转换成其他类型，请显式转换。

let label = "The width is "
let width = 94
let widthLabel = label + String(width)

有一种更简单的把值转换成字符串的方法：把值写到括号中，并且在括号之前写一个反斜杠（\）。例如：

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."
"""

使用方括号[]来创建数组和字典，并使用下标或者键（key）来访问元素。最后一个元素后面允许有个逗号。

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

数组在添加元素时会自动变大。

shoppingList.append("blue paint")
print(shoppingList)

使用初始化语法来创建一个空数组或者空字典。

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

如果类型信息可以被推断出来，你可以用[]和[:]来创建空数组和空字典。

shoppingList = []
occupations = [:]

控制流

使用if和switch来进行条件操作，使用for-in、while和repeat-while来进行循环。包裹条件和循环变量的括号可以省略，但是语句体的大括号是必须的。

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语句中，条件必须是一个布尔表达式。

你可以一起使用if和let一起来处理值缺失的情况。这些值可由可选值来代表。一个可选的值是一个具体的值或者是nil以表示值缺失。在类型后面加一个问号（?）来标记这个变量的值是可选的。

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

另一种处理可选值的方法是通过使用??操作符来提供一个默认值。

let nickName: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickName ?? fullName)"

你还可以使用较短的代码解包一个值，并且对该被包装值使用相同的名称。

if let nickname {
    print("Hey, \(nickName)")
}

switch支持任意类型的数据以及各种比较操作。

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.")
}

注意let在上述例子的等式中是如何使用的，它将匹配等式的值赋给常量x。运行switch中匹配到的case语句之后，程序会退出switch语句，并不会继续向下运行，所以不需要在每个子句结尾写break。

你可以使用for-in来遍历字典，需要一对儿变量来表示每个键值对。

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 (_, numbers) in interestingNumbers {
    for number in numbers {
        if number > largest {
            largest = number
        }
    }
}
print(largest)

使用while来重复运行一段代码直到条件改变。循环条件也可以在结尾，保证能至少循环一次。

var n = 2
while n < 100 {
    n *= 2
}
print(n)
var m = 2
repeat {
    m *= 2
} while m < 100
print(m)

你可以在循环中使用..<来表示下标范围。

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

使用..<创建的范围不包含上界，如果想包含的话需要使用...。

函数和闭包

使用func来声明一个函数，使用名字和参数来调用函数。使用->来指定函数返回值的类型。

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

默认情况下，函数使用它们的参数名称作为它们参数的标签，在参数名称前可以自定义参数标签，或者使用_表示不使用参数标签。

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

使用元组来生成复合值，比如让一个函数返回多个值。

func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
    var min = scores[0]
    var max = scores[0]
    var sum = 0
    for score in scores {
        if score > max {
            max = score
        } else if score < min {
            min = score
        }
        sum += score
    }
    return (min, max, sum)
}
let statistics = calculateStatistics(scores:[5, 3, 100, 3, 9])
print(statistics.sum)
print(statistics.2)

函数可以嵌套。被嵌套的函数可以访问外侧函数的变量。

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

函数是第一等类型，这意味着函数可以作为另一个函数的返回值。

func makeIncrementer() -> ((Int) -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
var increment = makeIncrementer()
increment(7)

函数也可以当做参数传入另一个函数。

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
})

有很多种创建更简洁的闭包的方法。例如：

let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)

你可以通过参数位置而不是参数名字来引用参数。

let sortedNumbers = numbers.sorted { $0 > $1 }
print(sortedNumbers)

对象和类

使用class和类名来创建一个类。

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

要创建一个类的实例，在类名后面加上括号。使用点语法来访问实例的属性和方法。

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

使用init来创建一个构造器。

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

子类的定义方法是在它们的类名后面加上父类的名字，用冒号分割。

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()

除了简单的存储属性，还有使用getter和setter的计算属性。

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
        }
    }
    override func simpleDescription() -> String {
        return "An equilateral triangle with sides of length \(sideLength)."
    }
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
print(triangle.perimeter)
triangle.perimeter = 9.9
print(triangle.sideLength)

如果你不需要计算属性，但是仍然需要在设置一个新值之前或者之后运行代码，使用willSet和didSet。

class TriangleAndSquare {
    var triangle: EquilateralTriangle {
        willSet {
            square.sideLength = newValue.sideLength
        }
    }
    var square: Square {
        willSet {
            triangle.sideLength = newValue.sideLength
        }
    }
    init(size: Double, name: String) {
        square = Square(sideLength: size, name: name)
        triangle = EquilateralTriangle(sideLength: size, name: name)
    }
}
var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")
print(triangleAndSquare.square.sideLength)
print(triangleAndSquare.triangle.sideLength)
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
print(triangleAndSquare.triangle.sideLength)

处理变量的可选值时，你可以在操作之前加?。

let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
let sideLength = optionalSquare?.sideLength

枚举和结构体

使用enum来创建一个枚举。

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

使用init?(rawValue:)初始化构造器来从原始值创建一个枚举实例。

if let convertedRank = Rank(rawValue: 3) {
    let threeDescription = convertedRank.simpleDescription()
}

枚举值是实际值，并不是原始值的另一种表达方法。

enum Suit {
    case spades, hearts, diamonds, clubs
    func simpleDescription() -> String {
        switch self {
        case .spades:
            return "spades"
        case .hearts:
            return "hearts"
        case .diamonds:
            return "diamonds"
        case .clubs:
            return "clubs"
        }
    }
}
let hearts = Suit.hearts
let heartsDescription = hearts.simpleDescription()

如果枚举成员的实例有原始值，那么这些值是在声明的时候就已经决定了。你也可以为枚举成员设定关联值。

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来创建一个结构体。

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()

并发性

使用async标记异步运行的函数。

func fetchUserID(from server: String) async -> Int {
    if server == "primary" {
        return 97
    }
    return 501
}

使用await来标记对异步函数的调用。

func fetchUsername(from server: String) async -> String {
    let userID = await fetchUserID(from: server)
    if userID == 501 {
        return "John Appleseed"
    }
    return "Guest"
}

使用async let来调用异步函数，并让其与其它异步函数并行运行。

func connectUser(to server: String) async {
    async let userID = fetchUserID(from: server)
    async let username = fetchUsername(from: server)
    let greeting = await "Hello \(username), user ID \(userID)"
    print(greeting)
}

使用Task从同步代码中调用异步函数。

Task {
    await connectUser(to: "primary")
}

协议和扩展

使用protocol来声明一个协议。

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

类、枚举和结构体都可以遵循协议。

class SimpleClass: ExampleProtocol {
    var simpleDescription: String = "A very simple class."
    var anotherProperty: Int = 69105
    func adjust() {
        simpleDescription += "  Now 100% adjusted."
    }
}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription
struct SimpleStructure: ExampleProtocol {
    var simpleDescription: String = "A simple structure"
    mutating func adjust() {
        simpleDescription += " (adjusted)"
    }
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription

使用extension来为现有的类型添加功能。

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

错误处理

使用采用Error协议的类型来表示错误。

enum PrinterError: Error {
    case outOfPaper
    case noToner
    case onFire
}

使用throw来抛出一个错误和使用throws来表示一个可以抛出错误的函数。

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

使用do-catch来进行错误处理。

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

可以使用多个catch块来处理特定的错误。

另一种处理错误的方式使用try?将结果转换为可选的。

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

使用defer代码块来表示在函数返回前，函数中最后执行的代码。

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)

泛型

在尖括号里写一个名字来创建一个泛型函数或者类型。

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)

你也可以创建泛型枚举和结构体。

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

在类型名后面使用where来指定对类型的一系列需求。

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

<T: Equatable>和<T> ... where T: Equatable的写法是等价的。