swift里的函数和闭包

在swift语言中，使用 func 来声明一个函数，通过函数的名字和参数来调用 函数。使用 -> 指定函数返回值（分离了返回值和参数）

举个简单的栗子，获取狗叫

func getDogSing() -> String {
    return "汪汪汪..."
}
getDogSing()

传递可变数量的参数，通过数组获取参数

func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf(2,3) //运行结果5
sumOf(2,3,4)//运行结果9

函数可以嵌套，被嵌套的函数可以访问外部函数的变量。可以通过函数的嵌套来重构太长或者太复杂的函数。

func getSum() -> Int {
    var y = 10
    func add() {
        y += 5
    }
    add()
    return y
}
getSum() //运行结果：15

swift中函数也是类型，这意味着函数可以使用另一个函数作为返回值

func add(v1:Double,v2:Double)->Double{
    return v1+v2
}

func minuse(v1:Double,v2:Double)->Double{
    return v1-v2
}

func getCaculateName(name:String)->(v1:Double,v2:Double)->Double{
    switch name {
        case "+":
            return add
        default:
            return minuse
    }
}
getCaculateName("+")(v1: 100,v2: 20) //运行结果：120

这里定义了两个方法add和minuse，顾名思义就是传入两个double类型的值即可计算出它们的和与差类型是double；

而getCaculateName(name:String)->(v1:Double,v2:Double)->Double这个函数的入参是String类型，返回值是另一种传入两个double类型返回double类型的函数。

函数也可以使用另一个函数作为参数

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 < 3
}
var numbers = [3,100,27,122]
hasAnyMatches(numbers,condition: lessThanTen) //返回结果：false

实际上函数是一种特殊的闭包。通过 {} 创建一个匿名的闭包，使用 in 将执行体和参数、返回值进行分离

例如定义一个String类型的字符串

var dogName = "大黑"

利用闭包定义可以是这样的

var str1:String = {
    return "大黑"
}()

闭包还可以这么定义，省略等号和括号

var dogName:String{
    return "大黑"
}

加入参数的闭包可以是这样

var dogName = {
    (arg1:String)->String in
    return arg1
}("大黑")

还不够，那就把参数也省略掉

var dogName = {
    return $0
}("大黑")

如果闭包中只有一行代码那就可以把return也省略掉

var dogName3={
     $0
}("大黑")

这里是用在定义变量用到的闭包，在函数中体现出来一样的,

func getCaculateName1(name:String)->(v1:Double,v2:Double)->Double{
    switch name {
    case "+":
        return {
            (s1:Double,s2:Double)-> Double in
                return s1+s2


        }
    default:
        return {
            (s1:Double,s2:Double)-> Double in
            return s1-s2
        }
    }
}

省略之后

func getCaculateName(name:String)->(v1:Double,v2:Double)->Double{
    switch name {
    case "+":
        return {
            $0 + $1
        }
    default:
        return {
            $0-$1
        }
    }
}
getCaculateName("+")(v1: 100,v2: 20)//运行结果：120
getCaculateName("-")(v1: 100,v2: 20)//运行结果：80

有多种更简明创建闭包的方法。如果一个闭包类型已知，比如作为一个回调函数，这时可以忽略它的参数类型、或则返回值类型、或则二者都忽略。单条语句的闭包可以直接将语句的结果当做返回值。

numbers.map({ number in 3 * number })

可以通过参数的位置而不是名称来引用参数–这对于简短的闭包来说非常有用；闭包作为最后一个参数传递给函数时，可以直接跟在括号后面。

sort([1,5,12,2]) { $0 > $1 }

暂时先跟新到这，明天继续。。。