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函数返回值支持任意数据类型,如:StringInt数组字典等。

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

// ([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, Int) -> void
func studentInfomation(studentName name: String, studentAge age: Int, StudentPhone phone: Int) {
    print("Student infomation: name is \(name), age is \(age), phone is \(phone)", terminator: "")
}

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

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

忽略外部参数名

  • 如果你不想为第二个及后续的参数设置参数名,请使用下划线(_)代替外部参数名。
// (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", 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...可变参数,在函数体内可以当做一个叫numbersDouble[]型的数组常量。

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

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, 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)
}

// 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) -> IntgetMathFunc()函数,接下来程序调用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))
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值