iOS开发Swift-函数

一、函数的定义

（1）函数的定义格式

1 func 函数名(形参列表) -> 返回值类型  {
2     // 函数体...
3 
4 }

（2）形参列表的格式

形参名1: 形参类型1, 形参名2: 形参类型2, … 

（3）举例：计算2个整数的和

1 func sum(num1: Int, num2: Int) -> Int {
2     return num1 + num2
3 }

（4）没有返回值的函数

　　如果函数没有返回值，有3种写法

func 函数名(形参列表) -> Void {
    // 函数体...
}

func 函数名(形参列表) -> () {
    // 函数体...
}

func 函数名(形参列表) {
 // 函数体...
}

（5）没有形参的函数

　　一个函数如果没有形参，函数名后面的小括号也不能省略

1 func 函数名() -> Int {
2     // 函数体...
3 }

　　上面的函数没有形参、返回值是Int类型

（6）返回元组的函数

一个函数也可以返回元组数据

func find(id: Int) -> (name: String, age: Int) {
    if id > 0 {
        return ("jack", 20)
    } else {
        return ("nobody", 0)
    }
}
var people = find(2)
println("name=(people.name), age=(people.age)")

二、外部参数名

1.简单说明

一般情况下，通过形式参数的名字，就能推断出这个参数的含义和作用

1 func addStudent(name: String, age: Int, no: Int) {
2     println("添加学生：name=(name)，age=(age)，no=(no)")
3 }

在函数内部一看参数名就知道这3个参数的作用

但是，形式参数是用在函数内部的，当调用函数时就看不见形参的名字，有可能导致以后会不太明白每个参数的含义

对于addStudent("jack", 20, 19)一眼望去，能猜出第1个参数"jack"是指姓名，后面的20、19分别代表什么含义？

为了解决上述问题，Swift提供了外部参数名语法

外部参数名可以在调用函数时提醒每个参数的含义

2.定义

外部参数名的定义格式如下：

1 func 函数名(外部参数名 形式参数名: 形式参数类型) -> 返回值类型  {
2       // 函数体...
3 }

外部参数名写在形式参数名的前面，与形式参数名之间用空格隔开

3.外部参数名的使用

1 func sum(number1 num1: Int, number2 num2: Int) -> Int
2 {
3     return num1 + num2
4 }
5 sum(number1: 10, number2: 20) // 调用函数

注意：一旦定义了外部参数名，在调用函数时就必须加上外部参数名

4.外部参数名的简写

使用#能简化外部参数名的定义

1 func sum(#num1 : Int, #num2 : Int)
2 {
3     return num1 + num2
4 }

第1行代码的意思：num1、num2既是形式参数名，又是外部参数名

// 调用函数  sum(num1: 10, num2: 20)

三、默认参数值

（1）可以在定义函数时，给形参指定一个默认值，调用函数时，就可以不用给这个形参传值

1 func addStudent(name: String, age: Int = 20) {
2     println("添加1个学生：name=(name)，age=(age)")
3 }

addStudent("jack")

age参数有个默认值20，所以第4行调用函数时可以不传值给age参数

输出结果是：

添加1个学生：name=jack，age=20

（2）带有默认参数值的形参，Swift会自动给它生成一个跟形参名相同的外部参数名

age: Int = 20相当于#age: Int = 20

因此，如果要传入age参数值时，只能这么调用

addStudent("jack", age: 25)

（3）在带有默认参数值的参数名前加个下划线 _ ，调用函数时就不用写外部参数名

1 func addStudent(name: String, _ age: Int = 20) {
2     println("添加1个学生：name=(name)，age=(age)")
3 }
4 
5 addStudent("jack", 25)

四、常量和变量参数

默认情况下，函数的参数都是常量参数，不能在函数内部修改

1 func test(num: Int) {
2     num = 10
3 }
4 
5 func test(num: Int)参数相当于func test(let num: Int)

注意：第2行代码会报错

在有些情况下，可能需要在函数内部修改参数的值，这时需要定义变量参数

在参数名前面加个var即可

1 func test(var num : Int) {
2     num = 10  
3 }

// 编写函数在某个字符串的尾部拼接N个其他字符串

func append(var string: String, suffix: String, count: Int) -> String
{
    for _ in 0..<count {
        string += suffix
    }
    return string
}
append("jack", ".", 4) // 调用函数
// jack....

五、输入输出参数

1.什么是输入输出参数？

在C语言中，利用指针可以在函数内部修改外部变量的值

在Swift中，利用输入输出参数，也可以在函数内部修改外部变量的值

输入输出参数，顾名思义，能输入一个值进来，也可以输出一个值到外部

2.输入输出参数的定义

在参数名前面加个inout关键字即可

func swap(inout num1: Int, inout num2: Int) {

}

3.代码示例：写一个函数交换外部2个变量的值

func swap(inout num1: Int, inout num2: Int) {
    let tempNum1 = num1
    num1 = num2
    num2 = tempNum1
}
var a = 20
var b = 10
swap(&a, &b) // 传入的参数前面必须加上&
// 执行完swap函数后，a的值是10，b的值是20

4.输入输出参数的使用注意

传递实参时，必须在实参的前面加上&

不能传入常量或者字面量（比如10）作为参数值（因为它们都不可改）

输入输出参数不能有默认值

输入输出参数不能是可变参数

输入输出参数不能再使用let、var修饰（inout和let、var不能共存）

输入输出参数的价值之一

　　可以实现函数的多返回值（其实让函数返回元组类型，也能实现返回多个值）

六、函数类型

函数类型也是数据类型的一种，它由形参类型和返回值类型组成，格式是

(形参类型列表) -> 返回值类型

1 func sum(num1: Int, num2: Int) -> Int {
2     return num1 + num2
3 }

sum函数的函数类型是(Int, Int) -> Int

1 func printLine()
2 {
3     println("-----------")
4 }

printLine函数的函数类型有4种表示方法

（1）Void -> Void 

（2）() -> ()

（3）Void -> ()

（4）() -> Void

七、利用函数类型定义变量

可以利用函数类型来定义变量，将来可以存储这种类型的函数

1 func sum(num1: Int, num2: Int) -> Int {
2     return num1 + num2
3 }
4 var fn: (Int, Int) -> Int = sum
5 fn(10, 20) // 返回30

由于Swift有类型推断机制，因此，也可以这么写

　　var fn = sum   // fn以后所存储函数的类型就必须是(Int, Int) -> Int

八、函数作为参数

跟其他数据类型一样，函数也能当函数的参数

1 func printResult(fn: (Int, Int) -> Int, num1: Int, num2: Int) 
2 {
3     println("运算结果是：%d", fn(num1, num2))
4 }

fn参数接收一个函数，这个函数必须返回Int、有2个Int类型的参数

func sum(num1: Int, num2: Int) -> Int {
    return num1 + num2
}
func minus(num1: Int, num2: Int) -> Int {
    return num1 - num2
}
printResult(sum, 20, 10) // 30
printResult(minus, 20, 10) // 10

九、函数作为返回值

跟其他数据类型一样，函数也能当函数的返回值

func goToWork() { println("去上班") }
func playFootball() { println("踢足球") }
func howToDo(day: Int) -> () -> () {
    if day < 6 {
        return goToWork
    } else {
        return playFootball
    }
}
var fn = howToDo(7)
fn() 
// 踢足球

十、函数重载

函数重载：函数名相同，函数类型不同

下面的2个函数构成重载

（1）函数名：sum，函数类型：(Int, Int) -> Int

1 func sum(num1: Int, num2: Int) -> Int {
2     return num1 + num2
3 }

（2）函数名：sum，函数类型：(Int, Int, Int) -> Int

1 func sum(num1: Int, num2: Int, num3: Int) -> Int {
2     return num1 + num2 + num3
3 }

十一、嵌套函数

全局函数：在全局作用域中定义的函数

嵌套函数：在某个函数体中定义的函数

代码示例：

 1 func howToDo(day: Int) -> () -> () {
 2     func goToWork() { println("去上班") }
 3     func playFootball() { println("踢足球") }
 4     if day < 6 {
 5         return goToWork
 6     } else { return playFootball }
 7 }
 8 var fn = howToDo(5)
 9 fn() // 去上班
10 goToWork() 

 注意：第10行是错误写法，嵌套函数的作用域仅限于定义嵌套函数的函数体内部