swift函数式编程（高级）-闭包，协议，扩展，泛型，可空链

swift函数式编程实际是非常灵活的，在函数的高级应用中，实际上还包括了闭包，协议，泛型等等oc中没有的概念，按照顺序介绍这些概念和应用。

一：闭包

闭包实际就是objective-c中的block，其实际就是定义一个函数体，并将其作为参数传递，它既可以是有名的，也可以是匿名的函数

1.1 闭包的定义和声明

闭包其本质就是将一个函数体作为变量或者常量，然后将函数体进行传递或者调用。函数的嵌套其实也是一种闭包。但是函数是不能捕捉上下文的，但是闭包可以。这是他们之间的一个大区别！！！！

var transform:(Int)->Int = {//定义一个变量闭包

(number:Int)->Int in//定义参数，申明参数列表和返回值

if number%2 == 0{

return number * 3

}else{

return 0
}
}

transform = {

(number:Int)->Int in

return 0
}

func transform1(a:Int)->Int{

return 1
}

var numbers = [2,53,3,7,8,3];
numbers.map(transform)//可以传递闭包，内部调用闭包，闭包的函数体才会执行。
numbers.map(transform1)//可以传递函数
transform(6)//必须调用，才会执行函数体
print(numbers.map(transform))
var tempNum = numbers.map {

(number:Int) -> Int in

if number%2 == 0{

return number * 3
}else{

return 0
}
}
print(tempNum)

1.2闭包的值捕获，跟block一样，闭包虽然类似于定义一个函数体的变量，但是闭包内部可以捕获上下文的值。
func factoria(factor:Int)->Int{//顶一个计算阶乘的函数

var total = 1

if(factor<=0){

return total
}

for item in 1...factor{

let mutiple:()->Int = {

total = total*item//内部捕获了函数体外部的total值和item值，函数是不能捕捉上下文的。这是他们的一个大区别！！！！
return total
}

mutiple()// 调用闭包函数体
}

return total
}

factoria(3)//打印结果是6


二：协议（swift中的协议跟objective-c中的协议有很大区别，objective-c中的协议用于代理，而swift中的协议更像是Java中的抽象类）
2.1协议的申明和定义已经实现

protocol Continer{//申明协议

typealias ItemType//申明类型
func apped(item:ItemType)//申明方法
var count:Int{get}//只读
subscript(i:Int)->ItemType{get}//只读
}

class IntArray:Continer {//实现协议

var array = [Int]()
typealias ItemType = Int
func apped(item: ItemType) {

array.append(item)
}
var count : Int{

return array.count
}
subscript(i:Int)->Int{

return array[i]
}
}
如果一个类实现了一个协议，就必须实现这个协议的所有方法和属性。
2.2 组合协议（实现了多个协议）

//组合协议
func allFunc(target:protocol<SomeProtocol,OtherProtocol>){//这个函数的参数是实现了所有这些协议的实例对象

target.someFunc()
target.otherFunc()

}
protocol SomeProtocol{

func someFunc()->()
}
protocol OtherProtocol{

func otherFunc()->()
}

class All:SomeProtocol,OtherProtocol {//类All实现了这2个协议

func someFunc() {

print("someFunc")
}

func otherFunc() {
print("oher")
}
}

var all = All()
allFunc(all)

三：扩展（与objective-c中的分类相似，可以扩展类的方法）
extension Array{

func contains(comparator:(Int)->Bool,value:Int)->Bool{//扩展了Array的一个新方法，参数可以传递闭包或者一个函数

for item in self{

if(comparator(value)){//在这里调用闭包

return true
}
}

return false

}

}
numbers = [1,2,3]
print(numbers)
numbers.contains(//在这里申明闭包
{
(element:Int) -> Bool in//传递的是闭包，必须写参数列表和返回值

for item in numbers{

if element == item{//判读闭包的参数值有没有跟数组中的值相同的。

return true
}
}

return false

}, value: 5)

print(numbers)


四.泛型，泛型也是objective-c中特有的，它可以不指定类型，可以代表任何的类型
//泛型函数
func removeLast<T>(inout array:Array<T>){//泛型函数中，必须在函数名之后先申明泛型

array.removeLast()
}
var array = [1,2,3,4]
removeLast(&array)

//泛型类型
class GenericTest<T>{//泛型类型是在类的定义是先申明泛型，但是在类实例化的时候必须知道泛型的具体类型

var objects = [T]()

}

//实例化的时候，必须指定泛型类型
var buffer1 = GenericTest<String>()
buffer1.objects += ["1","2","3"]
print(buffer1.objects)

var buffer2 = GenericTest<Int>()
buffer2.objects += [1,2,3]
print(buffer2.objects)

五：可空链（类似于强制拆箱，但不是强制拆箱，它能保证数据安全）
注意：可空链上如果存在着非可空的类型，它会自动装包成可空的类型。

class Outer {

var inner:Inner?
}

class Inner {

var innerInner:InnerInner?
}

class InnerInner {

var innerMostStr:String = ""

}

var outerOptional : Outer?
var inner : Inner?
var innerInner:InnerInner?

outerOptional = Outer()
inner = Inner()
innerInner = InnerInner()
innerInner?.innerMostStr = "123"
inner?.innerInner = innerInner
outerOptional?.inner = inner
print(outerOptional)
print(innerInner)

if (outerOptional?.inner?.innerInner?.innerMostStr != nil){//可空链上任何一个为空，则整个可空链都返回空（nil）

print(outerOptional?.inner?.innerInner?.innerMostStr)//可空链中如果有非可空的参数，会自动装包

}else{

print(outerOptional?.inner?.innerInner?.innerMostStr)
}

//可空链的应用
class Student{

var course = [SchoolCourse]()
subscript(i:Int)->SchoolCourse{

return course[i]
}
func numberOfCourse()->Int{

return course.count
}
func addCourse(c:SchoolCourse){

course .append(c)
}
}

class SchoolCourse {

var departMent:Department = Department()
let couseName : String
init(name:String){

couseName = name
}

func printCourseDescription(){

if let departmentDescrip = departMent.departmentDescription(){

print("\(self.couseName) is part of \(departmentDescrip)")

}else{

print(self.couseName)
}
}
}

class Department {

var departName : String?
var collegeOf:String?
func departmentDescription()->String?{

if departName != nil{

return departName;

}else if collegeOf != nil{

return collegeOf

}else{

return nil
}
}
}

let student = Student()
student.addCourse(SchoolCourse.init(name: "math"))
student.numberOfCourse()

let OptionalStudent : Student? = Student()
OptionalStudent?.numberOfCourse()

let student1 = Student()
let mathCourse = SchoolCourse.init(name: "math")
let mathDepartment = Department()
mathDepartment.departName = "Math Departhment"
mathCourse.departMent=mathDepartment
student1.addCourse(mathCourse)

let optionalStudent1 : Student? = student1
let longChain = optionalStudent1?[0].departMent.departmentDescription()
print(longChain)
print(optionalStudent1?[0].departMent)//默认会装包
//要么返回的是nil,要么返回的是optional(x)