iOS-swift-函数和闭包

一、函数

关键字：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")

使用元组（tuple）构建复合类型值。比如一个函数返回多个值。元组的元素可以通过名字或者下标获取。

     func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
         var min = scores[]
         var max = scores[]
         var sum = 

         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: [, , , , ])
     print(statistics.sum)
     print(statistics.)

函数可以使用变化的参数，这些参数将会放进数组里面。

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

函数里面可以嵌套函数。

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

函数可以作为另一个函数的类型

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

函数可以作为另一个函数的参数

     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 <
     }
     var numbers = [, , , ]
     hasAnyMatches(list: numbers, condition: lessThanTen)

二、闭包（closures）    函数是闭包的的一种特殊情况：代码块延时调用。

可以用大括号 {} 写一个闭包。 使用 "in" 把闭包参数和返回值从闭包体区分开来。

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

可以更简单，功能一样。

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

可以使用数值下标代替名字访问参数，这个对于简短的闭包很有用。

当一个闭包是函数的唯一参数，可以省略圆括号。

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

嗯，努力！