iOS巅峰之Swift 函数, 闭包详解(下)

// 函数嵌套 : 函数作用域中定义了一个另外一个函数, 内层函数的作用域中可以使用外层函数的参数
func hellocLanou(var num :Int ) {
    num++
    func hello23() {
        num++
    print(num)
    }
    hello23()
    num
}

hellocLanou(10)

func hellocLanou2() -> ((Int) ->String) {
    func hanshu(i:Int) -> String {
    return "\(i)"
    }
    return hanshu
}

hellocLanou2()
let hanshu = hellocLanou2()
let i = hanshu(2)


// 声明一个函数, 实现功能:(传入"+", "-", "*", "/")的字符串, 返回对应运算的函数:"+"--返回Int + Int = Int

// 返回值是函数, 可以用函数嵌套的形式实现, 但是并不是必须使用嵌套实现
func sumNumber(c:NSString) ->((Int , Int) ->Int)? {
    func sun(a:Int, b:Int) ->Int {
    return a + b
    }
    
    func sub(a:Int, b:Int) ->Int {
        return a - b
    }
    
    func mul(a:Int, b:Int) ->Int {
        return a * b
    }
   
    
    func div(a:Int, b:Int) ->Int {
        return a / b
    }
    
    switch c {
    case "+":
        return sun
    case "-":
        return sub
    case "*":
        return mul
    case "/":
        return div
    default:
        return nil
    }

   
}

//-----------------同上
func sun(a:Int, b:Int) ->Int {
    return a + b
}

func sub(a:Int, b:Int) ->Int {
    return a - b
}

func mul(a:Int, b:Int) ->Int {
    return a * b
}


func div(a:Int, b:Int) ->Int {
    return a / b
}

func sumNumber1(c:NSString) ->((Int , Int) ->Int)? {
    
    switch c {
    case "+":
        return sun
    case "-":
        return sub
    case "*":
        return mul
    case "/":
        return div
    default:
        return nil
    }
}



//func number(c:String) -> ((a:Int, b:Int) ->Int) {
//
//
//}

sumNumber1("+")
let hanshu2 = sumNumber1("+")
let result = hanshu2!(2, 4)

// 指定类型别名
typealias funcType = ((Int, Int) -> Int)
func func3() -> funcType {
    func hanshu5 (num1: Int, num2: Int) -> Int {
    return 0
    }
    return hanshu5
}

//****************闭包 相当于block
// 闭包有作匿名函数
//{
//    
//(参数列表) -> 返回值 in
//    函数的实现体
//}

// 使用系统排序函数对闭包的省略机制进行说明
var numbers = [11, 33, 4, 55, 77]
var numbers_result = numbers.sort({
    (n1:Int, n2:Int) -> Bool in
    return n1 > n2
})

// 闭包的参数类型可以省略
// 根据上下文进行类型推断
var number_result1 = numbers.sort({
(n1, n2) -> Bool in
    return n1 > n2
})

// in 前面的语句可以省略
// 此时没有参数名, 自动生成$0, $1进行代替使用
var numbers_result2 = numbers.sort({
 return $0 > $1  })

var numbers_result3 = numbers.sort({
    $0 > $1 // return也可以省略, 条件是:函数条件体内只有return语句
})

// 极简模式
var numbers_result4 = numbers.sort(>)


//n*****************此处以上是闭包的省略机制

// 尾随机制
// 尾随闭包
// 当闭包作为参数列表的最后一个参数是, 并且内容相对复杂, 可以尾随在参数列表的外面
var numbers_result5 = numbers.sort(){
(n1, n2) -> Bool in
    return n1 > n2
}

typealias myType = ((String) -> String)
func getPigName(name:String) -> String {
    return "pig = \(name)"
}

func pig(canshu:myType) -> myType {
    return getPigName
}

pig({
    (name:String) -> String in
    return "pig = \(name)"
})

// 闭包常用于参数, 函数常用与返回值

// "3" + "4" = "7"
// "3" + "4" = 7

typealias myType2 = ((String, String) -> Int)
func closure (clo:myType2) -> String {
let result_clo = clo("3" , "4")
    // description 转成字符串
    return result_clo.description
}

closure({

    (a:String, b: String) -> Int in
    return Int(a)! + Int(b)!
})

// 字符串转 Int Int (String)!