Swift高速入门之函数

函数

看一个函数的样例：

func addNumbers( let a:Int,let b:Int)->Int{
    return a+b;
}

实现两个数相加。函数必须以func开头，后面是函数名。小括号中是參数。箭头后面是返回类型。Swift中没有int之类的基本类型了。连表示数字都用类：Int。

由于參数没有在函数内改变值，所以參数定义成常量。

不论是类的方法或全局函数，语法一样。

不像ObjC那样，全局函数是C语法。类方法是ObjC语法。

这样调用它：

let r = addNumbers(3, b: 4)

能够看到从第二个參数開始，须要带參数名。

函数要通过return返回多个值在ObjC中是做不到的，当然你能够放到一个数组或字典中把这个数组或字典返回。返回后再取出来也比較麻烦。

假设你写的函数是给别人用的话，还要凝视说明确，里面的各项数据是怎样排列的。

但如今语法已经支持了：用元组！

以下这个样例是取得两个数相除的商和余数：

func divNumbers(a:Int,b:Int)->(shang:Int,yu:Int){
    return (shang:a/b,yu:a%b)
}

箭头后是返回值类型，看起来像參数，实际上就是定一了一个元组类型。

return时。定义了一个元组对象，填入了两个数据的值。

调用此函数：

let ret = divNumbers(7, b: 3)
print(ret)
print(ret.shang)

可变參数

函数也支持可变參数，以下是一个计算平均值的样例：

func average(numbers:Int...)->Float{
    var he=0
    for num in numbers {
        he += num
    }

    return Float(he)/Float(numbers.count)
}

能够看到可变參数在函数内实际上是一个数组。

嵌套定义

函数还能够嵌套定义。就是在一个函数体内定义还有一个函数，而且内部的函数能够任意使用所在函数的暂时变量。反过来就不行。如：

func test(){
    var a=0;
    //定义内部函数
    func add(){
        a+=100 //直接操作外部变量
    }
    //调用内部函数
    add()
    print(a)
}

函数做返回值

//返回值类型是一个函数，其參数是整型，返回是整型

func testReturn()->((Int)->Int){
    //定义要返回的函数
    func action(a:Int)->Int{
        return a*a
    }
    //返回这个函数对象
    return action
}
let retFunc = testReturn()
//定义返回的函数
let bb = retFunc(22)

这事并没有什么特殊的，在C语言时代就能够啊。

函数做參数

比方数组排序函数中，比較两个相邻元素的代码能够放到函数中。比較函数做为參数传入，样例：

//比較函数
func compare(arr:[Int],firstIndex:Int,secondIndex:Int)->Bool{
    if(arr[firstIndex]>arr[secondIndex]) {
        return true
    }
    return false
}

//冒泡排序
func sort(var arr:[Int],compareFunc:([Int],Int,Int)->Bool){
    //请大家自行写出冒泡排序代码。。。
    for(var i=arr.count-1;i>0;i--){
        for(var j=0;j<i;j++){
            //这里是比較的代码
            if(compareFunc(arr,j,j+1)){
                let tmp = arr[j]
                arr[j]=arr[j+1]
                arr[j+1]=tmp
            }
        }
    }
}
var arr = [100,33,22,4353,67,6865,43,454]
sort(arr,compareFunc: compare)

闭包

闭包跟嵌套函数实质没区别，能够直接用所在函数体的变量，唯一的区别就是名字。

用闭包实现比較函数：

sort(arr,compareFunc: {
    (arr:[Int],firstIndex:Int,secondIndex:Int)->Bool in
    if(arr[firstIndex]>arr[secondIndex]) {
        return true
    }
    return false
})

闭包的写法能够更简：

sort(arr,compareFunc: {
    if($0[$1]>$0[$2]) {
        return true
    }
    return false
})

能够看到省掉了函数类型说明，參数直接用序号来操作。

上一篇：Swift高速入门之分支与循环

来源：https://www.cnblogs.com/brucemengbm/p/7346308.html