Swift3.0-函数和闭包

使用func 声明一个函数。通过函数名称和参数调用一个函数。使用->区分参数名和函数返回的类型。

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

函数的参数可以有外部参数名和内部参数名，外部参数名标记函数传入的参数，内部参数名在函数实现的地方使用。_表示没有外边参数名。

func greet(on person:String, _ day:String)->String{
       return "Hello \(person), today is \(day)."
}
greet(on: "John", "Wednesday")

一个函数需要返回多个值可以使用元组。元组中的元素可以使用名称和下标访问。

func caculateStatistics(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(scores:[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 ) {//(Int) -> Int 表示返回函数的参数类型和返回类型
         func addOne(number:Int) ->Int {
                 return 1+number
        }
        return addOne
}
var increment = makeIncrementer() // 返回的是addOne函数
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 number = [20, 19, 7, 12]
hasAnyMatches(number,condition:lessThanTen)//只要number数组有一个元素小于10就返回true

当条件不同时只要传入不同的函数就可以了，这样可以节省代码实施的空间。

函数其实是一种特殊的闭包：能够稍后调用的代码块。运行时闭包中的代码可以访问闭包范围内甚至不在闭包体内的变量和函数，例如嵌套函数。你可以写一个没有名字只有大括号的闭包。在闭包体内使用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.sorted {$0 > $1}
print(sortedNumbers)

声明一个闭包变量，作为参数传入一个函数中

var myBlock:(String)->() = {
      name in
      print(name)
}

func myFunction(name:String,condition:(String)->()){
        condition(name)
}

myFunction("Jason",myBlock)

其实是跟函数作为参数传入一个函数中的道理一样