Swift2学习：Swift概览3-函数和闭包

函数和闭包

用func来声明一个函数。通过函数名和一串括号里的参数来调用他。使用->来区分参数和函数返回的所有类型。

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

greet("Huang", "0722")

练习

删掉名为day的参数。在greeting中添加特指今天午餐的参数。

使用元组来构成一个合成值--例如，函数返回多个值。元组的元素要么通过名称要么通过下标来引用。

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

函数也可以传入可变数量的参数，把他们塞进数组里。

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

print(sumOf())
print(sumOf(42,597,12))

练习

写一个用来计算入参平均值的函数。

函数可以被嵌套。嵌套函数可以访问在它之外的变量。你可以使用嵌套函数把函数中复杂或者很长的代码块组织起来。

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

returnFifteem()

函数是一个first-class类型。这意味着一个函数可以返回另外一个函数作为他的值。

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, 17, 12]
hasAnyMatches(numbers, lessThanTen)

函数其实是一种特殊情况下的闭包：代码块可以被稍后调用。闭包中的代码在他创建的范围内能够使用像变量和有效的函数这样的东西，即使当闭包运行在一个不同的范围--正如你已经看到的一个嵌套函数的例子。你可以不用写闭包的名字而通过大括号（{}）括住他的代码。使用in分割闭包主体的入参和返回类型。

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

练习

重写闭包达到当入参是奇数时返回0.

你拥有数个操作来更简明的书写闭包。当闭包的类型已经明确，就像委托的回调，你可以省略参数类型，返回类型，或者他们两者。单语句闭包隐式返回了他们唯一的声明的值。

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

你可以通过下标而不是名称引用参数--这种方法在非常短的闭包里很有用。闭包做为函数的最后一个参数时可以直接出现在圆括号之后。当闭包做为函数的唯一参数时，你可以省略圆括号。
let sortedNumbers = numbers.sort {$0 > $1}
print(sortedNumbers)