Swift_函数(Function)

函数(Function)

Swift中的函数，就相当于OC中的方法。但是语法上变化的地方很多，并且还增加了OC中没有的功能，下面详细介绍：

函数类型

无参数、无返回值

// func          : 函数标志
// function1     : 函数名
// ()            : 小括号内部放参数类型
// Void          : 返回值类型
func function1() -> Void {
    print("这是一个无参数无返回值的函数")
}

// 返回值Void可以省略，这种写法更加的方便，建议这种
func function2() {
    print("这是一个无参数无返回值的函数")
}

有参数、无返回值

// 有参数、无返回值
func printInt(a: Int) {
    print(a)
}

// 多个参数，无返回值
func printText(a: Int, b: Float, c: String) {
    print("\(a) \(b) \(c)")
}

无参数、有返回值

// 无参数、有一个返回值
func PI() -> Double {
    return 3.14
}

// 使用元组，实现多个返回值
func notFoundMsg() -> (Int, String) {
    return (404,  "Not Found")
}

有参数、有返回值

// 有两个Int参数、有一个Int返回值
func sumValue(a: Int, b: Int) -> Int {
    return a + b
}

// 有两个Int参数，有两个Int返回值
func sumAndDiffValue(a: Int, b: Int) -> (Int, Int) {
    return (a + b, a - b)
}

// 有一个数组类型参数，有两个Int类型参数
func maxAndMinValue(array: [Int]) -> (min: Int, max: Int) {
    var minValue = array[0]
    var maxValue = array[0]

    for value in array {
        if value < minValue {
            minValue = value
        } else if value > maxValue {
            maxValue = value
        }
    }

    return (minValue, maxValue)
}

// 函数调用，传递数组参数
let res = maxAndMinValue([10, 34, 23, 56, 23])
// 打印结果内容
print("\(res.min) \(res.max)")
// 打印结果： 10  56

内部参数名、外部参数名

函数的参数名，是方便我们对参数的理解，一个好的参数名可以提高我们的代码质量。
在Swift语言中，参数名可以分为内部参数名和外部参数名。很简单，内部参数名就是在函数内部使用的名字，而外部参数名，就在在函数调用的时候显示的名字。

默认参数名

// 函数名常用写法
func funcNames(name: String, age: Int, height: Float) {
    print("\(name) \(age) \(height)")
}

// 函数调用，显示: age / height，不显示: name
funcNames("李大泽", age: 18, height: 20)
// 默认情况下，函数的第一个参数，不显示外部参数名，其它参数外部参数名和内部参数名一样，并显示

写全内部参数名和外部参数名

// 手动添加外部参数名
// 如下： 
//      withName、withAge、withHeight是外部参数名，只能在函数调用的时候显示
//      name、age、height是内部参数名，只能在函数内部使用
func funcNames1(withName name: String, withAge age: Int, withHeight height: Float) {
    print("\(name) \(age) \(height)")
}

// 函数调用，显示:withName / withAge / withHeight
funcNames1(withName: "lidaze", withAge: 18, withHeight: 180)

隐藏掉外部参数名

在Swift中，如果需要忽略掉内容的话，请使用_符号，参数名也一样。 

// 隐藏掉外部参数名  
func funcNames2(name: String, _ age: Int, _ height: Float) {
    print("\(name) \(age) \(height)")
}
funcNames2("lidaze", 18, 180.0)

如果把参数名都省略掉得话，对于我们阅读代码增加的困难，不建议省略

可变、不可变参数

Swift中，在函数内部，默认是禁止对参数的值进行修改的，但是我们通过增加一些标识，可以实现参数的修改，详情如下： 

不可变参数

// 不可变参数
func notChangeParam1(let a: Int) {
    // 下面的代码报错
//    a = 10
}

// 参数是否可变默认是let，和上面写法一样
func notChangeParam2(a: Int) {
    // 下面的代码报错
//    a = 10
}

可变参数

当我们想要修改参数的值的时候，我们可以使用var修饰参数，注意，这样修改参数的值，并不影响实参的值。 

// 参数值可修改
func changeParam(var a: Int) {
    print(a)
    a = 10
    print(a)
}
// 如果想要修改参数的话，需要在函数定义的时候将参数设置成var类型，默认是let，不允许修改参数

输入、输出参数

大家都知道，在函数内部修改了参数，实参的值是不会发生改变的。那如果我们想要外部参数值改变呢？请使用inout参数

// 输入输出参数
func inoutParamFunc(inout a: Int) {
    a += 10
}

var num = 20
inoutParamFunc(&num)
print("num = \(num)")
// 30

如果参数使用inout关键字修饰的话，在函数内部修改参数的值，会影响到外部参数的值。类似于C语言中传递了参数的地址，然后利用地址修改了参数的值

默认参数值

在Swift中，我们调用函数的时候，有参数的函数我们也可以不传递参数，因为参数可以拥有默认值，如下： 

// 默认参数值
func defaultParam(a: Int = 12) {
    print(a)
}
defaultParam()
// 打印结果： 12
defaultParam(20)
// 打印结果： 20

可变参数

在Swift中，实现任意数量的参数是非常容易的一件事情，但是请注意，一个函数只允许一个可变数量的参数 

// 可变参数
func moreParams(numbers: Int...) {
    for number in numbers {
        print(number)
    }
}
moreParams(10, 20, 34, 24, 56, 24)
// 打印: 10, 20, 34, 24, 56, 24

每个函数，最多允许一个可变参数

嵌套函数

// 嵌套函数
func chooseFunc(a: Int, b: Int, funcName: String) -> Int {

    // 在Swift中，可以在函数内部声明函数
    func sum(a: Int, b: Int) -> Int {
        return a + b
    }

    func diff(a: Int, b: Int) -> Int {
        return a - b
    }

    if funcName == "sum" {
        return sum(a, b: b)
    } else {
        return diff(a, b: b)
    }
}
chooseFunc(10, b: 20, funcName: "sum")

函数嵌套的层级是无限制的，但是不建议很多