闭包(Closure)
自包含的函数代码块,可以在代码中被传递和调用
闭包可以捕获和存储其所在上下文中任意常量和变量的引用
闭包表达式:
{
(parameters) -> returnType in
statements
}
闭包可以使用常量、变量、inout类型作为参数,不提供默认值;元祖也可以作为参数和返回值
全局和嵌套函数实际上也是特殊的闭包
(1)全局函数是一个 有名字但不会捕获任何值 的闭包
(2)嵌套函数是一个 有名字可以捕获其封闭函数域内值的闭包
(3)闭包表达式是一个 捕获上下文变量和常量的匿名闭包
//!!!闭包的函数体部分由关键字in引入,该关键字表示闭包的参数和返回值类型定义已经完成,闭包函数体即将开始
/*
* 闭包(Closure)
自包含的函数代码块,可以在代码中被传递和调用
闭包可以捕获和存储其所在上下文中任意常量和变量的引用
闭包表达式:
{
(parameters) -> returnType in
statements
}
闭包可以使用常量、变量、inout类型作为参数,不提供默认值;元祖也可以作为参数和返回值
全局和嵌套函数实际上也是特殊的闭包
(1)全局函数是一个 有名字但不会捕获任何值 的闭包
(2)嵌套函数是一个 有名字可以捕获其封闭函数域内值的闭包
(3)闭包表达式是一个 捕获上下文变量和常量的匿名闭包
*/
//!!!闭包的函数体部分由关键字in引入,该关键字表示闭包的参数和返回值类型定义已经完成,闭包函数体即将开始
//sorted函数
let names:Array<String> = ["China","Alex","Ewa","Draw","Bob"]
let i = names.sorted {
(s1, s2) -> Bool in
return s1 > s2
}
print(i)
//尾部闭包
func someFunction(closure:() -> ()){
//函数体部分
}
//以下是不使用尾随闭包进行函数调用
someFunction (closure: {
//闭包主体部分
})
//使用尾随闭包进行函数调用
someFunction() {
//闭包主体部分
}
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]
func printOut() -> Void {
let strings = numbers.map {
(number) -> String in
var number = number
var output = ""
while number > 0{
output = digitNames[number % 10]! + output
number /= 10
}
return output
}
print(strings)
}
printOut()
/*
* 运算符重载
让已有的运算符可以对自定义的类和结构进行运算
*/
struct Point {
var x = 0.0,y = 0.0
}
func + (left:Point,right:Point) -> Point{
return Point(x:left.x+right.x,y:left.y+right.y)
}
let p1 = Point(x:3.0,y:1.0)
let p2 = Point(x:2.0,y:4.0)
let p3 = p1 + p2
print("p1=\(p1),p2=\(p2),p3=\(p3)")
//前置、后置运算符(prefix、postfix)
prefix func - (vector:Point) -> Point{
return Point(x:-vector.x,y:-vector.y)
}
let post = Point(x:3.0,y:4.0)
let nag = -post
let alp = -nag
print("post=\(post),nag=\(nag),alp=\(alp)")
//组合赋值运算符
func += (left:inout Point,right:Point){
left = left + right
}
var p5 = Point(x:1.0,y:2.0)
let p6 = Point(x:3.0,y:4.0)
p5 += p6
print("p5=\(p5)")
//自定义运算符
prefix operator +++
prefix func +++ (vector:inout Point) -> Point{
vector += vector
return vector
}
var beDou = Point(x:1.0,y:4.0)
let afterDou = +++beDou
print("beDou=\(beDou),afterDou=\(afterDou)")
/*
* 泛型函数:作用于任何类型
泛型使用了占位类型名字(通常用字母T来表示)来代替实际类型名字(如:Int、String等),占位类型名没有提示T必须是什么类型,但是它提示两个参数必须是同一类型T,不管T是什么类型,每次调用所传入实际类型才能决定T所代表类型
*/
print("\n泛型函数")
func swapTwoValues<T>(a:inout T,b:inout T){//要求两参数类型值一致
let c = a
a = b
b = c
}
var beA = "测试"
var beB = "test"
swapTwoValues(a: &beA,b:&beB)
print("a=\(beA),b=\(beB)")
//栈操作
print("\n栈操作")
struct Stack<T>{
var items = [T]()
mutating func push(item:T){
items.append(item)
}
mutating func pop() -> T{
return items.removeLast()
}
}
var stackString = Stack<String>()
stackString.push(item: "ni")
stackString.push(item: "wo")
stackString.push(item: "ta")
print(stackString.items)
extension Stack{
var topItem:T? {
return items.isEmpty ? nil : items[items.count - 1]
}
}
if let topItem = stackString.topItem{
print("The top item on the stack is \(topItem)")
}