Swift入门笔记

iOS Swift

https://developer.apple.com/swift/resources/

简单类型

• let常亮， var变量

• 强制类型转换

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

• Array， Dictionary

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

创建空array和Dictionary

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

如果类型可以推测的话，可以写得更简单

shoppingList = []
occupations = [:]

流程控制

if and switch to make conditionals,
use for-in, for, while, and repeat-while to make loops
条件上（）可选. Body上 {}必须

• switch
  支持各种类型的数据，也支持多种比较操作。
  每一块操作，运行完就完了，不会去比较下一个case，所以不需要break操作。

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

• for-in
  dictionary的For-in可以直接提供Key-value来遍历

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)

..< 标识循环范围，下面2个循环是一回事

var firstForLoop = 0
for i in 0..<4 {
    firstForLoop += i
}
print(firstForLoop)
var secondForLoop = 0
for var i = 0; i < 4; ++i {
    secondForLoop += i
}
print(secondForLoop)

ps ..<4 不包括4 , ...4 包括4

• while 和 repeat - while

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

• Optional Value
  ?，说明值能空
  ??，表示Default值

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

Functions and Closures

• 定义方法

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

• 可以使用Tulpe返回多个值

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([5, 3, 100, 3, 9])
print(statistics.sum)
print(statistics.2)

• 方法带不定个数的参数

func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf()
sumOf(42, 597, 12)

• 内部方法（Nested Function）
  内部方法可以是用外部方法的变量

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

• 方法作为返回值
  方法是一级类型(first-class type)，一个方法可以把方法作为返回值

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(numbers, condition: lessThanTen)

• 无名方法
  无名方法 用 ({})包裹，用in分隔参数返回类型和方法体

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

如果一个closure的类型已知，例如是一个delegate的callback，那么可以省略参数和返回类型

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

可以使用变量的编号而不是变量的名字来引用参数 $0
如果一个closure是某个方法唯一的参数的话，可以省略外面的（）

let sortedNumbers = numbers.sort { $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."
    }
}

* deinit相当于NSObject 中的 dealloc方法。

• 子类
  继承 - class 类名 ：父类名
  在方法前加上override表示覆盖某个父类的方法。编译器会自动检查是否override。

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 会在设置一个property的newValue的时候运行

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

? 表示可能为空

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

枚举和结构体

Protocols and Extensions