函数和闭包

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

func greet(name: String, food: String) -> String {
    return "Hello \(name), let's eat some \(food)"
}

greet("Lin", food: "fruit")

• 使用元组来让一个函数返回多个值。该元组的元素可以用名称或数字来表示。

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([10, 21, 25, 50, 3])
print(statistics.max)
print(statistics.2)   //表示返回值的位置
print(statistics.sum)

• 函数可以带有可变个数的参数，这些参数在函数内表现为数组的形式

func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf()
sumOf(1,2,3,4,5,6,7,8,9)

//计算平均值
func averageCalculate(numbers: [Int]) -> Float {
    var average: Float = 0.0
    var sum = 0
    for number in numbers {
        sum += number
    }
    let doubleSum = Float(sum)
    let count = Float (numbers.count)
    average = doubleSum / count
    return average
}

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

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

returnFifteen()

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

func makeIncrementer() -> (Int -> Int) {
    func addOne(number: Int) -> Int {
        return number + 1
    }
    return addOne
}

var incrementer = makeIncrementer()
incrementer(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,13, 12, 0]
hasAnyMatches(numbers, condition: lessThanTen)

• 函数实际上是一种特殊的闭包:它是一段能之后被调取的代码。闭包中的代码能访问闭包所建作用域中能得到的变量和函数，即使闭包是在一个不同的作用域被执行的 - 你已经在嵌套函数例子中所看到。你可以使用{}来创建一个匿名闭包。使用in将参数和返回值类型声明与闭包函数体进行分离。

numbers.map({
    (number: Int) -> Int in
    var result = 0
    if number % 2 == 0 && number != 0{
        return number
    }else{
        return 0
    }
})

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

• 有很多种创建更简洁的闭包的方法。如果一个闭包的类型已知，比如作为一个回调函数，你可以忽略参数的类型和返回值。单个语句闭包会把它语句的值当做结果返回。

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

• 你可以通过参数位置而不是参数名字来引用参数——这个方法在非常短的闭包中非常有用。当一个闭包作为最后一个参数传给一个函数的时候，它可以直接跟在括号后面。当一个闭包是传给函数的唯一参数，你可以完全忽略括号。

let sortedNumbers = numbers.sort {$0 < $1}
print(sortedNumbers)

对象和类

• 使用class和类名来创建一个类。类中属性的声明和常量、变量声明一样，唯一的区别就是它们的上下文是类。同样，方法和函数声明也一样。

class Shape {
    let word = "Hi"
    var numberOfSides = 0
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides"
    }
    func phrase(name: String) -> String {
        return "\(word), \(name)"
    }
}

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

var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()
var shapePhrase = shape.phrase("Lin")

• 这个版本的Shape类缺少了一些重要的东西：一个构造函数来初始化类实例。使用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"
    }
}

• 注意self被用来区别实例变量,当你创建实例的时候，像传入函数参数一样给类传入构造器的参数。

• 子类的定义方法是在它们的类名后面加上父类的名字，用冒号分割。创建类的时候并不需要一个标准的根类，所以你可以忽略父类。

• 子类如果要重写父类的方法的话，需要用override标记——如果没有添加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: 1.2, name: "Lin")
test.area()
test.simpleDescription()

class Circle: NamedShape {
    var radius: Double
    
    init(radius: Double, name: String) {
        self.radius = radius
        super.init(name: name)
        numberOfSides = 5
    }
    func area() -> Double {
        return radius * radius * 3.1415
    }
    
    override func simpleDescription() -> String {
        return "this is a circle named \(name), area is \(area())"
    }
}

let testCircle = Circle(radius: 7.24, name: "Lin")
testCircle.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 {
            return sideLength = newValue / 3.0
        }
    }
    override func simpleDescription() -> String {
        return "An equilateral triangle with sides of length \(sideLength)"
    }
}

var triangle = EquilateralTriangle(sideLength: 9.0, name: "Triangle")
triangle.perimeter
triangle.perimeter = 99.0
triangle.sideLength

• 在perimeter的 setter 中，新值的名字是newValue。你可以在set之后显式的设置一个名字。

• 注意EquilateralTriangle类的构造器执行了三步：

设置子类声明的属性值
调用父类的构造器
改变父类定义的属性值。其他的工作比如调用方法、getters和setters也可以在这个阶段完成。

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

class SquareAndTriangle {
    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 = SquareAndTriangle(size: 3.0, name: "T&S")
triangleAndSquare.square.sideLength
triangleAndSquare.triangle.sideLength
triangleAndSquare.square = Square(sideLength: 8.0, name: "Lix")
triangleAndSquare.triangle.sideLength

• 处理变量的可选值时，你可以在操作（比如方法、属性和子脚本）之前加?。如果?之前的值是nil，?后面的东西都会被忽略，并且整个表达式返回nil。否则，?之后的东西都会被运行。在这两种情况下，整个表达式的值也是一个可选值。

let optionalSquare: Square? = Square(sideLength: 8.0, name: "Lin")
let sideLength = optionalSquare?.sideLength
sideLength