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
Swift 学习记录(4)
最新推荐文章于 2024-03-08 08:57:25 发布