swift函数式编程-函数基础

来源：互联网发布：sql获取当前时间编辑：程序博客网时间：2024/05/19 22:49

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.0sum2(&firstValue, values: 1,2,3)//传递的是指针print(firstValue)//外部的参数值已经被改变，此时打印的是11sum2(&firstValue, values: 1,2,3)//可以看出参数值已经在前一个函数中被改变，此时打印的结果是17

1.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)

1 0