swift的函数式编程比较灵活，主要有函数，闭包（objective-c中的block），协议，扩展，泛型，可空链等等，下面就逐个解释。
一：函数
函数是函数式编程的基础和一部分，函数类似于其他的语言，例如Java，objective-c，都是由函数名，参数，返回值，函数体组成，只是在写法上有细微的区别。
1.1函数的定义
func isInclude(isInclude:String,inArray:Array<String>)->Bool{//函数定义
for item in inArray{
if isInclude == item{
return true
}
}
return false
}
isInclude("0", inArray: ["1","2","3"])1.2外部参数名（即在调用函数的时候，显示参数名）
func isInclude(target isInclude:String,strings inArray:Array<String?>)->Bool{
for item in inArray{
if item == isInclude{
return true
}
}
return false
}
isInclude(target: "1", strings: ["1","2","3"])//调用函数的时候，显示参数名target和strings.
1.3 参数默认值（即给函数的参数赋予默认的值）
func isInclude2(target isInclude:String="a",strings inArray:Array<String>)->Bool{
for item in inArray{
if item == isInclude{
return true
}
}
return false
}
isInclude2(target: "2", strings: ["1","2","3"])//参数虽然有默认值，但是仍然重新赋值
isInclude2(strings: ["a","b","c"])//参数不重新赋值，用默认值，即target是默认的字符串"a"
1.4变量参数（参数值是变量，即参数是可以改变的）
func sum(var firstValue:Double,values:Double...)->Double{//参数默认是常量let，除非用var标识，才是变量
for item in values{
firstValue += item//参数在函数内部可以改变
}
return firstValue
}
sum(2, values: 1,2,3)1.5输入/输出参数（即在函数内部可以修改外部变量的值，其实质是指针的传递，而不是值传递），一般情况下都是值传递，即函数内部不能改变函数外部的值。但是输入输出参数是指针传递,内部是可以修改外部值的。
func sum2(inout firstValue:Double,values:Double...)->Double{//输入输出参数要inout作为标识。
for item in values{
firstValue += item
}
return firstValue
}
var firstValue = 5.0
sum2(&firstValue, values: 1,2,3)//传递的是指针
print(firstValue)//外部的参数值已经被改变，此时打印的是11
sum2(&firstValue, values: 1,2,3)//可以看出参数值已经在前一个函数中被改变，此时打印的结果是171.5函数本身作为参数
func max(bigger:(Double,Double)->Double,values:Double...)->Double{//max函数有一个函数参数，这个函数参数的格式是（Double,Double）->Double。任何符合这个格式的函数（或者是闭包）都可以作为参数
var maxValue = values[0]
for var i=0;i<values.count;++i{
maxValue = bigger(maxValue,values[i])
}
return maxValue
}
func bigger2(firstValue:Double,secondValue:Double)->Double{//符合上面的参数格式
return firstValue>secondValue ? firstValue : secondValue
}
func bigger(firstValue:Double)->Double{//不符合上面参数的格式
return 0
}
max(bigger2, values: 1,2,3)//返回值是3，验证正确1.6 函数作为返回值
//降序
func desc(values:Double...)->[Double]{//定义一个降序方法
var results = values
for var i = 0;i < values.count;++i{
for var j = i+1;j < values.count;++j{
if results[j]>results[i]{
let temp = results[j]
results[j] = results[i]
results[i] = temp
}
}
}
return results
}
//升序
func asc(values:Double...)->[Double]{//定义一个升序方法
var results = values
for var i = 0;i < results.count;++i{
for var j = i + 1; j < results.count; ++j{
if (results[i]>results[j]){
let temp = results[i]
results[i] = results[j]
results[j] = temp
}
}
}
return results
}
func sort(orderType:Int)->((values:Double...)->[Double]){//定义一个选择哪个函数的方法，返回的函数必须遵从（values:Double...）->[Double]这个形式
return orderType == 0 ? asc : desc// asc和desc函数必须遵从上面参数和返回值的形式
}
//升序
var sortFunc = sort(0)//返回的值是一个升序函数
sortFunc(values: 1,4,2,6,3)//调用这个返回的函数
//降序
sortFunc = sort(1)//返回一个降序函数
sortFunc(values: 1,4,2,6,3)// 调用这个返回的降序函数
1.7嵌套函数（其本质也是闭包）
func sortFunc(orderType:Int,values:Double...)->[Double]{
func asc(values:[Double])->[Double]{//嵌套的第一个函数，升序。必须调用的时候，这个函数才会执行，否则不会执行。参数不能是区间，要是数组。
var results = values
for var i = 0;i < results.count;++i{
for var j = i + 1; j < results.count; ++j{
if (results[i]>results[j]){
let temp = results[i]
results[i] = results[j]
results[j] = temp
}
}
}
return results
}
func desc(values:[Double])->[Double]{//嵌套的第二个函数，降序
var results = values
for var i = 0;i < values.count;++i{
for var j = i+1;j < values.count;++j{
if results[j]>results[i]{
let temp = results[j]
results[j] = results[i]
results[i] = temp
}
}
}
return results
}
return orderType == 0 ? asc(values) : desc(values)//values在这里会被自动转换成数组，而不是区间！！！，所以上面2个函数的参数是数组，而不是区间！！
}
sortFunc(0, values: 5,2,4,1,6,4)