0、函数概念：
函数相当于 OC 中的方法
函数的格式：
func 函数名(参数列表) -> 返回值类型{
代码块
return 返回值
}
- func 是定义函数的关键字
- 如果有多个参数，参数列表之间用逗号 “,” 分割，也可以没有参数
- 使用 “->” 指向返回值类型
- 如果没有返回值，返回值类型为 Void，并且 “-> Void” 部分也可以省略，也可以改为 “-> ()”
例：
func test() -> Int{
return 12;
}
let a = test() //12
一、函数的基本使用
- 参数、返回值的多种组合
- 没有参数没有返回值
func test11() -> Void{
print("没有参数没有返回值")
}
test11() //"没有参数没有返回值"
- 有参数没有返回值
func test12(str:String) {
print("有参数:\(str)，没有返回值")
}
test12(str: "wangyijiang") //"有参数:wangyijiang，没有返回值"
- 没有参数，有返回值
func test13() -> Int{
return 13;
}
let a13 = test13() //13
- 有参数有返回值
func test14(a:Int,b:Int) -> Int{
return a + b
}
let a14 = test14(a: 5, b: 4) //9
- 函数有多个返回值
func test15(a:Int,b:Int) -> (Int,Int){
return (a+2,b+3)
}
let a15 = test15(a: 8, b: 7)
a15.0 //10
a15.1 //10
二、函数的内部参数、外部参数
内参：在函数内部可以看到的参数；
外参：在函数外部可以看到的参数；
在3.0之后，默认情况下，函数参数既是内参也是外参；
标签的使用：为了让函数调用者知道参数的意义。
func test21(name str1:String,addr str2:String) -> String{
return "姓名是：\(str1),家庭住址为：\(str2)"
}
let info21 = test21(name: "王义江", addr: "北京海淀") //"姓名是：王义江,家庭住址为：北京海淀"
- 如果不想要外部参数，在前面加下划线 “__” 即可
func test22(name str1:String,_ str2:String) -> String{
return "姓名是：\(str1),家庭住址为：\(str2)"
}
let info22 = test22(name: "yijiang", "北京海淀") //"姓名是：yijiang,家庭住址为：北京海淀"
三、默认参数
- 在某些情况下，如果没有传入具体的参数，可以使用默认参数:
func test31(第一个数 a:Int,第二个默认参数 b:Int = 8,第三个默认参数 c:Int = 6) -> Int{
return a + b + c
}
- 调用方式一：只传必选参数:
let a311 = test31(第一个数: 5) //19
- 调用方式二：传入所有参数:
let a312 = test31(第一个数: 7, 第二个默认参数: 3, 第三个默认参数: 2) //12
- 调用方式三：传入必须参数和任意一个默认参数组合:
let a313 = test31(第一个数: 2, 第二个默认参数: 7) //15
let a314 = test31(第一个数: 3, 第三个默认参数: 5) //16
四、可变参数
- 当输入参数个数不确定时，可使用可变参数
func test41(a41:Int...) -> Int{
var temp = 0
for value in a41 {
temp += value
}
return temp
}
test41(a41: 1,2,3) //6
注意点：所有参数的类型必须要一致，此例中都为 Int 类型
可变参数在函数内部当作数组来处理；在函数外面，直接传递过来多个参数，每个参数都是独立的个体
参数为数组时的比较：
func test42(a42:Array<String>) -> String{
var temp:String = ""
for value in a42 {
temp += value
}
return temp
}
test42(a42: ["yijiang","wang"]) //yijiangwang
- 传入的参数是一个数组，是一个整体
五、函数使用注意点：
- 在函数内部，默认接受到的参数被赋值给一个常量，是不允许修改的；
- 引用类型（指针的传递）：关键字 inout。
func test51( a51:inout Int, a52:inout Int){
let temp = a51
a51 = a52
a52 = temp
}
var b51 = 20
var b52 = 10
test51(a51: &b51, a52: &b52)
b51 //10
b52 //20
- 函数的嵌套使用
Swift 中，允许函数进行嵌套使用
func test52(){
func test53(){
print("第二层函数")
}
print("第一层函数")
test53()
}
test52()
//第一层函数
//第二层函数
六、函数的类型
- 概念：每个函数都有属于自己的类型，由参数类型和返回值类型组成
func testAdd61(a61:Double,b61:Double) -> Double{
return a61 + b61
}
//函数的类型为：(Double, Double) -> Double
func testMultipul62(a62:Double,b62:Double) -> Double{
return a62 * b62
}
//函数的类型为：(Double,Double) -> Double
- 使用
- 函数作为另外一个函数的参数
func test63(a63:Double,b63:Double,method:(Double,Double) -> Double){
method(a63, b63)
}
test63(a63: 5, b63: 6, method: testAdd61) //11
test63(a63: 5, b63: 6, method: testMultipul62) //30
- 函数作为另外一个函数的返回值
func test64(str:String) -> (Double,Double) -> Double{
if str == "add" {
return testAdd61
}else{
return testMultipul62
}
}
test64(str: "add")(3,4) //7
test64(str: "123")(3,4) //12
此时，可以将返回值类型放在 （） 中，更有层次感：
func test64(str:String) -> ((Double,Double) -> Double){
if str == "add" {
return testAdd61
}else{
return testMultipul62
}
}
test64(str: "add")(3,4) //7
test64(str: "123")(3,4) //12
