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