-
创建函数
// 创建函数，无参，无返回值，同 func func1() -> Void
func func1() {
print("no params func")
}
func1()
// 创建函数，带参，带返回类型
func func2(param: Int) -> Bool {
return param > 60
}
func2(param: 80)
// 创建函数，带多个参数，返回类型为元组
func func3(param1: String, param2: Int) -> (result1: String, result2: Int) {
return (param1 + "11", param2 + 20)
}
let tuple = func3(param1: "param", param2: 60)
if tuple.result1.starts(with: "param") {
print(tuple.result2)
}
// 创建函数，带参，返回类型为 Optional
func func4(param: Int) -> Int? {
guard param > 2 else {
return nil
}
return param + 2
}
if let result = func4(param: 3) {
print(result)
}
-
函数内外参数命名
// 函数参数指定外部名称
func outerNameFunc(name1 param1: Int, name2 param2: Int, param3: Int) {
print(param1, param2, param3)
}
// 函数参数使用外部名称
outerNameFunc(name1: 1, name2: 2, param3: 3)
func normalFunc(param1: Int, param2: Int, param3: Int) {
print(param1, param2, param3)
}
// 默认函数参数的内部名称和外部名称一致，调用函数时需要指定参数名称
normalFunc(param1: 1, param2: 2, param3: 3)
// 调用函数时省略参数名称
func annoFunc(_ param1: Int, _ param2: Int, _ param3: Int) {
print(param1, param2, param3)
}
annoFunc(1, 2, 3)
-
函数参数指定默认值
func func5(param1: Int, param2: Int = 2, param3: Int = 3) {
print(param1, param2, param3)
}
// 调用时，可以只传入没有默认值的参数
func5(param1: 1)
// 调用时，参数位置要严格对应
func5(param1: 1, param2: 22)
// 函数参数指定默认值
func func6(param1: Int, param2: Int = 2, param3: Int) {
print(param1, param2, param3)
}
// 调用时，参数位置要严格对应
func6(param1: 1, param3: 33)
-
可变参数
// 函数传入多个可变数量的参数，类似于 Kotlin 的 vararg
func mutableParamFunc(param: Int...) {
var sum = 0
for ele in param {
sum += ele
}
print(sum)
}
mutableParamFunc(param: 1, 2)
mutableParamFunc(param: 1, 2, 3, 4)
// swift 的函数参数值（除引用类型外）默认是不可修改的
func immutableParam(param: Int) {
// param += 1 // 编译失败 error: left side of mutating operator isn't mutable: 'param' is a 'let' constant
}
// 为了可以在函数参数内部修改参数值，可以使用 inout 修饰参数
func immutableParam(param:inout Int) {
param += 1 // 编译通过
print(param) // 2
}
// 调用时需要使用 & 符号
var number = 1
immutableParam(param: &number)
print(number) // 2, number的值也被修改了
-
函数类型引用，函数嵌套
// 函数可以作为类型进行声明，就像使用其他类型一样
let func7Name: (Int, Int) -> Bool
// 将闭包赋值给函数变量
func7Name = {(param1: Int, param2: Int) in
return param1 > param2
}
// 调用函数变量
func7Name(1, 2) // false
// 函数作为参数传入
func func8(funParam: (Int, Int) -> Bool) {
print(funParam(2, 1)) // true
}
// 将 func7 传入 func8
func8(funParam: func7Name)
// 函数作为返回值类型
func func9() -> (Int, Int) -> Bool {
return func7Name // 将 func7Name 返回
}
// 函数嵌套
func outerFunc() {
let outerScope = "outer scope"
func innerFunc() {
print(outerScope, "in inner func")
}
// 在外部函数内调用内部嵌套函数，在外部函数以外无法调用它
innerFunc()
}
// 调用外部函数
outerFunc()
-
defer的用法
很简单，用一句话概括，就是 defer block 里的代码会在函数 return 之前执行，无论函数是从哪个分支 return 的，还是有 throw，还是自然而然走到最后一行。
func testDefer() {
defer {
print("方法中defer内容")
}
if true {
defer {
print("if 中defer内容")
}
print("if中最后的代码")
}
print("方法中的代码")
if true {
return
}
print("方法结束前最后一句代码")
}
testDefer()
