Swift 学习记录（4）

import Foundation


/***嵌套函数***/

func getMathFunc(type:String) -> (Int)-> Int
{
    func squre(num:Int)->Int
    {
        return num*num;
    }
    
    func cube(num:Int)->Int
    {
        return num*num*num;
    }

    switch type {
    case "squre":
        return squre;
    case "cube":
        return cube;
    default:
        return cube;
    }
    
}

var mathFunc = getMathFunc("squre");
print(mathFunc(3));



/***闭包----嵌套函数的简化表达
    1.没有函数名
    2.大括号提前到形参列表前
    3.返回值后面加in表示函数体
 
 ***/

//{(形参列表) -> 返回值类型 in
//    可执行表达式
//}

//刚才嵌套函数的简化
func getMathFunc01(type:String) -> (Int)-> Int
{
    switch type {
    case "squre":
        return {(num:Int)->Int in
                return num*num;
        };
    case "cube":
        return {(num:Int)->Int in
            return num*num*num;
        };
    default:
        return {(num:Int)->Int in
            return num*num*num;
        };
    }
    
}
var mathFunc01 = getMathFunc01("squre");
print(mathFunc01(5));

mathFunc01 = getMathFunc01("cube");
print(mathFunc01(5));



//---------根据上下文推断类型


//省略形参类型和返回值类型,swift会根据变量类型推断
var squre:(Int) -> Int = {(num) in return num*num }
print(squre(3))

//可以推断形参类型,小括号也可以省略
var squre1:(Int) -> Int = {num in return num*num }
print(squre1(3))

//如果闭包中的函数体只有一行代码，那么return就可以省略
var squre2:(Int) -> Int = {num in num*num }
print(squre2(3))

//省略形参名，用$0,$1...表示第一个，第二个参数...
var squre3:(Int) -> Int = { $0 * $0 }

print(squre3(3))





var names = ["Mike", "John", "Mary", "Tom", "Bill"]

//  从小到大排序
func sortFun(s1:String, s2:String) -> Bool
{
    return s1 < s2;
}
// inout
var sortedNames = names.sort(sortFun);
print(sortedNames)


//  第1步 改成闭包形式
var sortedNames1 = names.sort({(s1:String, s2:String) -> Bool in return s1 < s2})

//  第2步 省略参数类型
var sortedNames2 = names.sort({(s1, s2) -> Bool in return s1 < s2})

//  第3步 省略返回值类型
var sortedNames3 = names.sort({(s1, s2) in return s1 < s2})

// 第4步 省略return语句
var sortedNames4 = names.sort({(s1, s2) in s1 < s2})

//  第5步 省略形参名，用$0,$1...表示第一个，第二个参数...
var sortedNames5 = names.sort({$0 < $1})

//  第6步 运算符函数   Swift 的String类型定义了关于大于号（>）的字符串实现，其作为一个函数接受两个String类型的参数并返回Bool类型的值。而这正好与sort(_:)方法的第二个参数需要的函数类型相符合。因此，可以简单地传递一个大于号，Swift 可以自动推断出您想使用大于号的字符串函数实现：
var sortedNames6 = names.sort(<)

print(sortedNames6)




var result:Int = {

    var temp = 1
    for i in 1...$1
    {
        temp *= $0
    }
    
    return temp
    
}(4,3)


print(result)


/**
 尾随闭包  如果函数的最后一个参数值是闭包，可以将闭包写在函数体外面
 */

func  someFunction(num:Int , fn:(Int) -> ()){
    
}

someFunction(20, fn:{_ in })

someFunction(20) {_ in }



let digitNames = [
    0: "Zero", 1: "One", 2: "Two",   3: "Three", 4: "Four",
    5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine"
]
let numbers = [16, 58, 510]

let strings = numbers.map {
    (number) -> String in
    var t = number
    var output = ""
    while t > 0 {
        output = digitNames[t % 10]! + output
        t /= 10
    }
    return output
}

print(strings)

//捕获上下文中的变量或者常量
//即使这些常量和变量所在的作用域不存在时，捕获的常量与变量仍会保存最后一次使用它们的值
func makeIncrementor(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementor() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementor
}

let incrementByTen = makeIncrementor(forIncrement: 10)

//runningTotal 仍可以正常使用
print(incrementByTen())
print(incrementByTen())
print(incrementByTen())

//10
//20
//30

let incrementBySeven = makeIncrementor(forIncrement: 7)
incrementBySeven()
// 返回的值为7

incrementByTen()
// 返回的值为40