10-Swift 函数

0、函数概念：

• 函数相当于 OC 中的方法

• 函数的格式：

func 函数名(参数列表) -> 返回值类型{
    代码块
    return 返回值
}

• func 是定义函数的关键字
• 如果有多个参数，参数列表之间用逗号 “,” 分割，也可以没有参数
• 使用 “->” 指向返回值类型
• 如果没有返回值，返回值类型为 Void，并且 “-> Void” 部分也可以省略，也可以改为 “-> ()”

例：

func test() -> Int{
    return 12;
}

let a = test()      //12

一、函数的基本使用

• 参数、返回值的多种组合
• 没有参数没有返回值

func test11() -> Void{
      print("没有参数没有返回值")
}
test11()    //"没有参数没有返回值"

• 有参数没有返回值

func test12(str:String) {
      print("有参数:\(str)，没有返回值")
}
test12(str: "wangyijiang")      //"有参数:wangyijiang，没有返回值"

• 没有参数，有返回值

func test13() -> Int{
      return 13;
}
let a13 = test13()      //13

• 有参数有返回值

func test14(a:Int,b:Int) -> Int{
      return a + b
}
let a14 = test14(a: 5, b: 4)    //9

• 函数有多个返回值

func test15(a:Int,b:Int) -> (Int,Int){
    return (a+2,b+3)
}
let a15 = test15(a: 8, b: 7)
a15.0   //10
a15.1   //10

二、函数的内部参数、外部参数

• 内参：在函数内部可以看到的参数；

• 外参：在函数外部可以看到的参数；

• 在3.0之后，默认情况下，函数参数既是内参也是外参；

• 标签的使用：为了让函数调用者知道参数的意义。

func test21(name str1:String,addr str2:String) -> String{
    return "姓名是：\(str1),家庭住址为：\(str2)"
}
let info21 = test21(name: "王义江", addr: "北京海淀")  //"姓名是：王义江,家庭住址为：北京海淀"

• 如果不想要外部参数，在前面加下划线 “__” 即可

func test22(name str1:String,_ str2:String) -> String{
    return "姓名是：\(str1),家庭住址为：\(str2)"
}
let info22 = test22(name: "yijiang", "北京海淀")    //"姓名是：yijiang,家庭住址为：北京海淀"

三、默认参数

• 在某些情况下，如果没有传入具体的参数，可以使用默认参数:

func test31(第一个数 a:Int,第二个默认参数 b:Int = 8,第三个默认参数 c:Int = 6) -> Int{
    return a + b + c
}

• 调用方式一：只传必选参数:

let a311 = test31(第一个数: 5)   //19

• 调用方式二：传入所有参数:

let a312 = test31(第一个数: 7, 第二个默认参数: 3, 第三个默认参数: 2)      //12

• 调用方式三：传入必须参数和任意一个默认参数组合:

let a313 = test31(第一个数: 2, 第二个默认参数: 7)      //15
let a314 = test31(第一个数: 3, 第三个默认参数: 5)      //16

四、可变参数

• 当输入参数个数不确定时，可使用可变参数

func test41(a41:Int...) -> Int{
    var temp = 0
    for value in a41 {
        temp += value
    }
    return temp
}
test41(a41: 1,2,3)      //6

• 注意点：所有参数的类型必须要一致，此例中都为 Int 类型

• 可变参数在函数内部当作数组来处理；在函数外面，直接传递过来多个参数，每个参数都是独立的个体

• 参数为数组时的比较：

func test42(a42:Array<String>) -> String{
    var temp:String = ""
    for value in a42 {
        temp += value
    }
    return temp
}
test42(a42: ["yijiang","wang"])     //yijiangwang

• 传入的参数是一个数组，是一个整体

五、函数使用注意点：

• 在函数内部，默认接受到的参数被赋值给一个常量，是不允许修改的；
• 引用类型（指针的传递）：关键字 inout。

func test51( a51:inout Int, a52:inout Int){
    let temp = a51
    a51 = a52
    a52 = temp
}
var b51 = 20
var b52 = 10

test51(a51: &b51, a52: &b52)
b51    //10
b52    //20

• 函数的嵌套使用
  Swift 中，允许函数进行嵌套使用

func test52(){
    
    func test53(){
        print("第二层函数")
    }
    
    print("第一层函数")
    test53()
}
test52()
//第一层函数
//第二层函数

六、函数的类型

• 概念：每个函数都有属于自己的类型，由参数类型和返回值类型组成

func testAdd61(a61:Double,b61:Double) -> Double{
    return a61 + b61
}
//函数的类型为：(Double, Double) -> Double

func testMultipul62(a62:Double,b62:Double) -> Double{
    return a62 * b62
}
//函数的类型为：(Double,Double) -> Double

• 使用
• 函数作为另外一个函数的参数

func test63(a63:Double,b63:Double,method:(Double,Double) -> Double){
      method(a63, b63)
}
test63(a63: 5, b63: 6, method: testAdd61)   //11
test63(a63: 5, b63: 6, method: testMultipul62)     //30

• 函数作为另外一个函数的返回值

func test64(str:String) -> (Double,Double) -> Double{
      if str == "add" {
        return testAdd61
      }else{
        return testMultipul62
      }
}
test64(str: "add")(3,4)     //7
test64(str: "123")(3,4)     //12

此时，可以将返回值类型放在 （） 中，更有层次感：

func test64(str:String) -> ((Double,Double) -> Double){
      if str == "add" {
        return testAdd61
      }else{
        return testMultipul62
      }
}
test64(str: "add")(3,4)     //7
test64(str: "123")(3,4)     //12