@H_404_134@

/*

*闭包（Closure）

自包含的函数代码块，可以在代码中被传递和调用

闭包可以捕获和存储其所在上下文中任意常量和变量的引用

闭包表达式：

{

(parameters)->returnTypein

statements

}

闭包可以使用常量、变量、inout类型作为参数，不提供默认值；元祖也可以作为参数和返回值

全局和嵌套函数实际上也是特殊的闭包

（1）全局函数是一个有名字但不会捕获任何值的闭包

（2）嵌套函数是一个有名字可以捕获其封闭函数域内值的闭包

（3）闭包表达式是一个捕获上下文变量和常量的匿名闭包

*/

//！！！闭包的函数体部分由关键字in引入，该关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始

//sorted函数

letnames:Array<String>=["China","Alex","Ewa","Draw","Bob"]

leti=names.sorted{

(s1,s2)->Boolin

returns1>s2

}

print(i)

//尾部闭包

funcsomeFunction(closure:()->()){

//函数体部分

//以下是不使用尾随闭包进行函数调用

someFunction(closure:{

//闭包主体部分

})

//使用尾随闭包进行函数调用

someFunction(){

letdigitNames=[

0:"Zero",1:"One",2:"Two",3:"Three",4:"Four",

5:"Five",6:"Six",7:"Seven",8:"Eight",9:"Nine"

]

letnumbers=[16,58,510]

funcprintOut()->Void{

letstrings=numbers.map{

(number)->Stringin

varnumber=number

varoutput=""

whilenumber>0{

output=digitNames[number%10]!+output

number/=10

}

returnoutput

print(strings)

printOut()

*运算符重载

让已有的运算符可以对自定义的类和结构进行运算

*/

structPoint{

varx=0.0,y=0.0

func+(left:Point,right:Point)->Point{

returnPoint(x:left.x+right.x,y:left.y+right.y)

letp1=Point(x:3.0,y:1.0)

letp2=Point(x:2.0,y:4.0)

letp3=p1+p2

print("p1=\(p1),p2=\(p2),p3=\(p3)")

//前置、后置运算符(prefix、postfix)

prefixfunc-(vector:Point)->Point{

returnPoint(x:-vector.x,y:-vector.y)

letpost=Point(x:3.0,108); list-style:decimal-leading-zero outside; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> letnag=-post

letalp=-nag

print("post=\(post),nag=\(nag),alp=\(alp)")

//组合赋值运算符

func+=(left:inoutPoint,right:Point){

left=left+right

varp5=Point(x:1.0,y:2.0)

letp6=Point(x:3.0,108); list-style:decimal-leading-zero outside; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> p5+=p6

print("p5=\(p5)")

//自定义运算符

prefixoperator+++

prefixfunc+++(vector:inoutPoint)->Point{

vector+=vector

returnvector

varbeDou=Point(x:1.0,108); list-style:decimal-leading-zero outside; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> letafterDou=+++beDou

print("beDou=\(beDou),afterDou=\(afterDou)")

/*

*泛型函数:作用于任何类型

泛型使用了占位类型名字（通常用字母T来表示）来代替实际类型名字（如：Int、String等），占位类型名没有提示T必须是什么类型，但是它提示两个参数必须是同一类型T，不管T是什么类型，每次调用所传入实际类型才能决定T所代表类型

print("\n泛型函数")

funcswapTwoValues<T>(a:inoutT,b:inoutT){//要求两参数类型值一致

letc=a

a=b

b=c

varbeA="测试"

varbeB="test"

swapTwoValues(a:&beA,b:&beB)

print("a=\(beA),b=\(beB)")

//栈操作

print("\n栈操作")

structStack<T>{

varitems=[T]()

mutatingfuncpush(item:T){

items.append(item)

mutatingfuncpop()->T{

returnitems.removeLast()

varstackString=Stack<String>()

stackString.push(item:"ni")

stackString.push(item:"wo")

stackString.push(item:"ta")

print(stackString.items)

extensionStack{

vartopItem:T?{

returnitems.isEmpty?nil:items[items.count-1]

iflettopItem=stackString.topItem{

print("Thetopitemonthestackis\(topItem)")

}