Swift详解之三----------函数(你想知道的都在这里)

前端之家收集整理的这篇文章主要介绍了Swift详解之三----------函数(你想知道的都在这里)前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

函数(你想知道的都在这里)

注:本文为作者自己总结,过于基础的就不再赘述 ,都是亲自测试的结果。如有错误或者遗漏的地方,欢迎指正,一起学习。


1、 函数的简单定义和调用

简单的无参函数就不再赘述 , name为形参 ,也是内部在数名 。

  1. func sayHello(name:String) ->String
  2. {
  3. return name+" say: hello"
  4. }

调用的时候也很简单 sayHello("zhangsan")
是不是很简单呀!

2、外部参数名

什么是外部参数名呢,其实就是你给形参起得一个有意义的别名,让别人更理解这个参数的用途 。

  1. func sayHello1(YourNmae name:String,name2:String) ->String
  2. {
  3. return name+" say: hello "+name2
  4. }

这里调用的时候要加上这个别名sayHello1(YourNmae: "zhangsan",name2:"lisi")
swift 默认从第二个参数开始自动加外部参数名,等于内部参数名 。
如果你不想输入外部参数名可以在前面加个下划线

  1. //忽略外部参数名
  2. func add(a:Int,_ b:Int) ->Int
  3. {
  4. return a + b
  5. }
  6. add(1,1) //2

3、参数默认值

函数传入参数的时候可以给一个默认值,传参数的时候这个有默认值的可传可不传

  1. func plus(a:Int,another b:Int=0) -> Int
  2. {
  3. return a+b;
  4. }

这里给b的默认值是0,在调用的时候 print(plus(1)) 得到结果是1 , plus(1,another:2) 得到结果是3

4、可变参数

可变参数(variadic parameter)可以接受一个或多个值。函数调用时,你可以用可变参数来传入不确定数量的输入参数。通过在变量类型名后面加入(…)的方式来定义可变参数。

传入可变参数的值在函数体内当做这个类型的一个数组

  1. func arithmeticMean(numbers: Double...) -> Double {
  2. var total: Double = 0
  3. for number in numbers {
  4. total += number
  5. }
  6. return total / Double(numbers.count)
  7. }

这里numbers被当成了一个数组 arithmeticMean(1,2,3,4,5.5) 得到结果 3.1

也可以传String 或者任何其他类型

  1. func say(name:String,content:String ... )
  2. {
  3. var str = name;
  4. for item in content
  5. {
  6. str += item + " "
  7. }
  8. print(str)
  9. }

调用say("lily ",content:"like","eat","apple") 结果:lily like eat apple

5、常量参数和变量参数

函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误

我这里尝试去修改name的值,这里提示我不能修改let value

但是,有时候,如果函数中有传入参数的变量值副本将是很有用的。你可以通过指定一个或多个参数为变量参数,从而避免自己在函数中定义新的变量。变量参数不是常量,你可以在函数中把它当做新的可修改副本来使用。

这时候我们需要,通过在参数名前加关键字 var 来定义变量参数:

  1. func say1(var name:String)->String
  2. {
  3. name += "2"
  4. return name;
  5. }

调用函数say1("wangwu") 得到结果:wangwu2

6、函数类型(Function Types)

什么是函数类型呢? 其实每个函数都有种特定的函数类型,由函数的参数类型和返回类型组成。比如上面的say1函数类型就是(String)->String ,无参数和返回值的 ()->() 返回Void类型的函数

看下swift中Void其实是一个空得元组

下面看下怎么使用函数类型 。

  • 函数类型变量
    var mySay:(String)->String = say1

    跟定义普通的变量一样 ,把函数类型当普通类型使用即可,这里say1 就是我们前面写的那个函数
    当然我们也可以利用swift的只能推断,不指定类型var mySay = say1
    调用的时候跟调用普通函数一样mySay("hello") 结果:hello2

  • 函数类型作为参数类型

    1. func sayWord(mySay:(String)->String,name:String)->String
    2. {
    3. return mySay(name)
    4. }

    这里我们定义了一个函数,需要传入两个参数,第一个参数是一个函数类型的 (String)->String, 最后返回一个String .
    调用的时候我们可以在这里给它传一个定义好得函数 sayWord(say1,name: "my"), 结果:my2
    我们也可以使用闭包sayWord({ "\($0)2" },name: "my") 结果:my2
    在这里有些人可能还不太了解闭包,先不用管下一节会详细介绍 。

  • 函数类型作为返回类型

    有时候我们需要在不同的情况下使用不同的函数 ,比如我们需要传入一个数字,这个数字大于0使用Forward ,小于 0 使用 Backward , 当然这里只是简单的逻辑,可以用if - else搞定 ,但是逻辑十分复杂的时候可以分两个函数来写

    来看下例子 :

    1. func stepForward(input: Int) -> Int {
    2. return input + 1
    3. }
    4. func stepBackward(input: Int) -> Int {
    5. return input - 1
    6. }
    7. func chooseFunc(distance:Int) -> (Int)->Int
    8. {
    9. return distance>10 ? stepBackward:stepForward
    10. }

    这里定义两个非常简单的函数 ,还是在定义了一个根据传入参数而选定函数函数

    1. var input = 10;
    2. for i in 8...14
    3. {
    4. input = chooseFunc(i)(input)
    5. print(input)
    6. }

    我们在这里 分别给函数传入8 –14 ,得到的函数在传入10 ,看下这个数字的改变 ,结果是 :11 12 13 12 11 10 9 这个应该很容易理解

7、返回元组

我们的函数也可以返回一个元组类型

  1. func minMax( arr:Int ... )->(max:Int,min:Int)
  2. {
  3. var max = 0
  4. var min = 0
  5. for item in arr
  6. {
  7. if(item<max)
  8. {
  9. max = item
  10. }
  11. if(item>min)
  12. {
  13. min = item
  14. }
  15. }
  16. return (max,min)
  17. }

这是一个很简单的函数 ,传入一个可变参数 ,然后求出这写里面的最大和最小值 。调用minMax(2,5,88,98,-3) 结果 :(.0 -3,.1 98)

可选元组 - 有时候我们函数里面返回的是一个nil ,所以这是我们就需要把我们的元组写成可选元组。
注意:(Int,Int)? 与 (Int?,Int?) 不同, (Int,Int)? 表示整个元组是可选的 而不是每个元素是可选的

  1. func mm()->(max:Int,min:Int)?
  2. {
  3. return nil
  4. }
  5. if let c = mm()
  6. {
  7. print("aa")
  8. }else
  9. {
  10. print("bb")
  11. }

这段代码最后输出的是 bb

8、输入输出参数 inout

函数的参数声明成inout 这个值可以在函数修改 , 然后被传出函数 替换原来的值,所以不能只传入 字面量 要传入地址 加 &

  1. var myDate = 9
  2. func normalFunc(var data:Int)
  3. {
  4. data = 100
  5. }
  6. normalFunc(myDate)
  7. print(myDate) //9
  8.  
  9. func inoutFunc(inout data:Int)
  10. {
  11. data = 100
  12. }
  13. inoutFunc(&myDate)
  14. print(myDate) //100

可以看到,普通函数不会改变实参的值,而inout回改变 。传得时候一定要加上 &,其实不加也会爆错得。。

9、嵌套函数

你可以把函数定义在别的函数中 叫做嵌套函数 嵌套函数对外界是不可见的

还是我们刚才那几个函数 ,还可以这么玩。

  1. func MychooseFunc(distance:Int) -> (Int)->Int
  2. {
  3. func stepBackward(input: Int) -> Int {
  4. return input - 1
  5. }
  6. func stepForward(input: Int) -> Int {
  7. return input + 1
  8. }
  9. return distance>10 ? stepBackward:stepForward
  10. }

暂时先这么多吧, 以后想到什么再来补充 ,大家可以收藏了当字典,忘记了来查查用法

猜你在找的Swift相关文章