Swift - 函数

简介

• 函数是用来完成特定任务的独立的代码块。

函数的定义与调用

• 定义函数：func 函数名（参数列表）->返回值 { 实现部分 }

关键字    函数名       参数           返回值
func   sayHello (name: String) -> String {
    // 函数实现
    return "Hello," + name + "!"
}

注意：参数列表中，如果有多个参数，请使用逗号（,）隔开。

函数参数与返回值

• 有返回值，使用-> 返回值类型。

• 无返回值，有如下三种表现方式：

  • 直接省略-> 返回值类型部分。

  • 使用-> ()指定返回一个空元组声明没有返回值。

  • 使用-> void声明返回void代表没有返回值。

• 函数参数与返回值在不同情况下的声明与实现：

// 无参无返回值
func noParametersAndReturnValues() -> Void {
    print("Hello,world!")
}

// 无参有返回值
func noParametersHasReturnValues() -> String {
    return "value"
}

// 有参有返回值
func hasParametersAndReturnValues(var a: Int) -> Int {
    return a++
}

// 有参无返回值
func hasParametersNoReturnValues(name: String) -> Void {
    print("Hello,(name).")
}

函数返回值

• Swit函数返回值支持任意数据类型，如：String、Int、数组、字典等。

• 如果函数有多个返回值，请使用元组类型作为返回值类型，示例如下：定义一个函数，传入数组，返回数组中的最大值以及最小值。

// ([Int]) -> (Int,Int)
func maxAndMinNumber(numbers: [Int]) -> (max: Int,min: Int)? {
    var maxNumber = numbers[0]
    var minNumber = numbers[0]

    for var i = 0; i < numbers.count; i++ {
        maxNumber = numbers[i] > maxNumber ? numbers[i] : maxNumber
        minNumber = numbers[i] < minNumber ? numbers[i] : minNumber
    }
    return (maxNumber,minNumber)
}

let (max,min) = maxAndMinNumber([1,3,2,4,5,9])!

print("max number is '(max)',min number is '(min)'.",terminator: "")

函数参数名称

• 函数参数都有一个外部参数名和一个本地参数名，外部参数名用来标记传递给函数调用的参数，本地参数名在实现函数的时候使用。

// (String,Int,Int) -> void
func studentInfomation(name: String,age: Int,phone: Int) {
    print("Student infomation: name is (name),age is (age),phone is (phone)",terminator: "")
}

studentInfomation("Edward",age: 19,phone: 13219038892)

• 从上述例子中可以看出，在一般情况下，第一个参数省略其外部参数名，第二个以后的参数使用其本地参数名作为自己的外部参数名，所有参数需要有不同的本地参数名，但可以共享相同的外部参数名。

指定外部参数名

• 在本地参数名前指定外部参数名，中间以空格分隔。

// (String,Int) -> void
func studentInfomation(studentName name: String,studentAge age: Int,StudentPhone phone: Int) {
    print("Student infomation: name is (name),terminator: "")
}

studentInfomation(studentName: "Edward",studentAge: 19,StudentPhone: 13219038892)

注意： 如果你提供了外部参数名,那么函数在被调用时,必须使用外部参数名。

忽略外部参数名

• 如果你不想为第二个及后续的参数设置参数名，请使用下划线（_）代替外部参数名。

// (String,_ age: Int,_ phone: Int) {
    print("Student infomation: name is (name),19,13219038892)

注意: 因为第一个参数默认忽略其外部参数名称,明确写下划线是多余的。

默认参数值

• 你可以在函数体中为每个参数定义默认值 。当默认值被定义后，调用这个函数时可以忽略这个参数。

func sumOfNumbes(a: Int,b: Int = 10) {
    print(a + b)
}

sumOfNumbes(10) // 执行 10 + 默认值(10)，输出 20
sumOfNumbes(10,b: 20) // 执行 10 + 20，输出 30

注意: 将带有默认值的参数放在函数参数列表的最后。这样可以保证在函数调用时,非默认参数的顺序是一致 的,同时使得相同的函数在不同情况下调用时显得更为清晰。

可变参数

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

• 传入可变参数的值在函数体内当做这个类型的一个数组。例如，一个叫做numbers的型Double...可变参数，在函数体内可以当做一个叫numbers的Double[]型的数组常量。

• 下面的这个函数用来计算一组任意长度数字的算术平均数：

func arithmeticMean(numbers: Double...) -> Double {
    let count: Int = numbers.count
    var sum: Double = 0
    var average: Double = 0

    for number in numbers {
        sum += number
    }

    average = sum / Double(count)

    return average
}

print("average is '(arithmeticMean(1,2,3,4,5))'.") // 输出 average is '3.0'.

常量参数和变量参数

• 函数参数默认是常量试。图在函数体中更改参数值将会导致编译错误。这意味着你不能错误地更改参数值。

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

• 通过在参数名前加关键字var来定义变量参数：

func getResults(var a: Int) -> Int {

    for index in 1...3 {
        a += index
    }
    return a
}

print(getResults(10)) // 输出 16

输入输出参数

• Swift语言是值类型语言，当程序执行变量赋值、参数传递时，程序所传递的只是副本，因此在函数体内无论对参数做了哪些修改，对参数本身不会产生任何影响。对于Swift的引用类型，当程序执行变量赋值、参数传递时，由于程序传递的是引用（也就是指针），并未赋值对象的副本，因此在函数体内可以对参数本身进行修改。

• 除了类、函数和闭包是引用类型外，Swift的绝大部分类型都是值类型，在默认情况下，值类型的参数传入函数内部只是传入副本，因此函数无法对值类型的参数产生任何影响。

• 如果程序确实需要把值类型的参数传入函数内部，则可以使用In-Out参数，通过inout关键字即可声明In-Out参数，列入下列函数：

// 定义两个 In-Out 参数
func swap(inout a: Int,inout b: Int) {
    // 在函数内部交换两个形参的值
    let temp = a
    a = b
    b = temp
}

• 上面程序中定义swap()函数时，该函数中两个行程都是用inout关键字声明的，这表明它们都是In-Out参数，因此在该函数体内对参数a、b所做的修改会影响参数本身。

• 对于Int-Out类型的参数，调用该函数时只能传入对应的变量，不能是常量，不能是表达式，不能是非定的值，因为函数需要对In-Out参数进行赋值，只有变量才能被重新赋值。而且传入变量时还需要在变量名之前添加&地址符号。

var a = 6
var b = 9

print("交换之前，a的值：(a)， b的值：(b)")

swap(&a,&b)

print("交换之后，a的值：(a)， b的值：(b)")

// 输出：
交换之前，a的值：6， b的值：9
交换之后，a的值：9， b的值：6

函数类型

• Swift的每个函数都有特定的函数类型，函数类型就像数据类型一样，即可用于定义变量，也可用作函数的形参类型，还可作为函数的返回值类型。

// 1、无参无返回值，函数类型为：() -> void
func noParametersAndReturnValues() -> Void {
    print("Hello,world!")
}

// 2、无参有返回值，函数类型为：() -> String
func noParametersHasReturnValues() -> String {
    return "value"
}

// 3、有参有返回值，函数类型为：([Int]) -> (Int,minNumber)
}

// 4、有参无返回值，函数类型为：(String) -> void
func hasParametersNoReturnValues(name: String) -> Void {
    print("Hello,(name).")
}

使用函数类型

• 在Swift中，使用函数类型就像使用其他类型一样。例如，你可以定义一个类型为函数的常量或变量，并将函数赋值给它；有相同匹配类型的不同函数可以被赋值给同一个变量，就像非函数类型的变量一样:

// (Int,Int) -> Int
func sumOfNumber(a: Int,b: Int) -> Int {
    return a + b
}

var mathFunction: (Int,Int) -> Int = sumOfNumber

print(mathFunction(2,3)) // 输出 5

函数类型作为参数类型

• 可以用(Int,Int) -> Int这样的函数类型作为另一个函数的参数类型。这样就可以将函数的一部分实现交由给函数的调用者。

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

func printSumOfNumberResults(function: (Int,Int) -> Int,a: Int,b: Int) { let results = function(a,b) print("results is (results).",terminator: "") } printSumOfNumberResults(sumOfNumber,a: 100,b: 100)

函数类型作为返回类型

• Swift支持定义函数类型的返回值，这样即可将其他函数作为函数的返回值，例如如下程序：

// 定义一个计算平方的函数
func square(val: Int) -> Int {

    return Int(pow(Double(val),2.0))
}

// 定义一个计算立方的函数
func cube(val: Int) -> Int {
    return Int(pow(Double(val),3.0))
}

// 定义一个计算阶乘的函数
func factorial(val: Int) -> Int {
    var result = 1
    for index in 2...val {
        result *= index
    }
    return result
}

// 定义函数，该函数的返回值类型为：(Int) -> Int
func getMathFunc(type: String) -> (Int) -> Int {
    switch (type) {
        case "square":
            return square
        case "cube":
            return cube
        case "factorial":
            return factorial
    default:
        print("输入有误!")
        return square
    }
}

// 调用 getMathFunc() 函数，程序将返回一个 (Int) -> Int  类型的函数
var mathFunc = getMathFunc("square") // 得到 square 函数
print(mathFunc(5))

mathFunc = getMathFunc("cube") // 得到 cube 函数
print(mathFunc(5))

mathFunc = getMathFunc("factorial") // 得到 factorial 函数
print(mathFunc(5))

• 上面程序中定义了一个getMathFunc()函数，该函数的返回值类型为：(Int) -> Int，这是一个函数类型，也就是getMathFunc()函数将会返回一个类型为：(Int) -> Int的函数，接下来 getMathFunc()函数内分别使用了3条不同的return语句返回不同的函数，但他们的类型都是：(Int) -> Int。

• 一旦定义了返回值类型为(Int) -> Int的getMathFunc()函数，接下来程序调用getMathFunc()函数时即可返回(Int) -> Int类型的函数，上面程序中最后的几个函数调用中通过调用getMathFunc()函数分别得到了3个不同的(Int) -> Int函数。

嵌套函数

• 前面介绍的所有函数都叫全局函数，它们定义在全局域中。你也可以把函数定义在别的函数体中，称作嵌套函数。

• 默认情况下，嵌套函数是对外界不可见的，但是可以被他们封闭函数来调用。一个封 函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用。

• 下面使用嵌套函数修改之前定义的getMathFunc()函数。

// 定义函数，该函数的返回值类型为：(Int) -> Int
func getMathFunc(type: String) -> (Int) -> Int {
    // 定义一个计算平方的函数
    func square(val: Int) -> Int {

        return Int(pow(Double(val),2.0))
    }

    // 定义一个计算立方的函数
    func cube(val: Int) -> Int {
        return Int(pow(Double(val),3.0))
    }

    // 定义一个计算阶乘的函数
    func factorial(val: Int) -> Int {
        var result = 1
        for index in 2...val {
            result *= index
        }
        return result
    }

    // 该函数的返回值是嵌套函数
    switch (type) {
    case "square":
        return square
    case "cube":
        return cube
    case "factorial":
        return factorial
    default:
        print("输入有误!")
        return square
    }
}

// 调用 getMathFunc() 函数，程序将返回一个 (Int) -> Int  类型的函数
var mathFunc = getMathFunc("square") // 得到 square 函数
print(mathFunc(5))

mathFunc = getMathFunc("cube") // 得到 cube 函数
print(mathFunc(5))

mathFunc = getMathFunc("factorial") // 得到 factorial 函数
print(mathFunc(5))