Swift2.2 学习笔记(三) ___函数和闭包

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

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

使用一个元祖来返回多个值

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)

函数可以嵌套。被嵌套的函数可以访问外侧函数的变量，可以使用嵌套函数来重构一个太长或者太复杂的函数

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(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.sort{ $0 > $1 }
print(sortedNumbers)