Swift - 函数_app_内存溢出

概述简介函数是用来完成特定任务的独立的代码块。函数的定义与调用定义函数：func 函数名（参数列表）->返回值 { 实现部分 } 关键字函数名参数返回值func sayHello (name: String) -> String { // 函数实现 return "Hello, " + name + "!"} 注意：参数列表中，简介函数是用来完成特定任务的独立的代码块。函数的定义与调用定义函数：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) -> voIDfunc 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) -> voIDfunc 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)，输出 20sumOfNumbes(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 = 6var b = 9print("交换之前，a的值：\(a)， b的值：\(b)")swap(&a,&b)print("交换之后，a的值：\(a)， b的值：\(b)")// 输出：交换之前，a的值：6， b的值：9交换之后，a的值：9， b的值：6

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

// 1、无参无返回值，函数类型为：() -> voIDfunc noparametersAndReturnValues() -> VoID {    print("Hello,world!")}// 2、无参有返回值，函数类型为：() -> Stringfunc noparametersHasReturnValues() -> String {    return "value"}// 3、有参有返回值，函数类型为：([Int]) -> (Int,minNumber)}// 4、有参无返回值，函数类型为：(String) -> voIDfunc hasParametersnoreturnValues(name: String) -> VoID {    print("Hello,\(name).")}

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

// (Int,Int) -> Intfunc sumOfNumber(a: Int,b: Int) -> Int {    return a + b}var mathFunction: (Int,Int) -> Int = sumOfNumberprint(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) -> Intfunc 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) -> Intfunc 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))