func的为函数关键字,->表示 返回类型
func clickOK(name:String) -> Int {
print("bbb")
// 调用函数changeName
changeName(num: 3, age: 12)
return 2;
}
// 返回 void
func changeName(num:Int, age:Int) {
let abrag = num + age
}
- 使用下划线
_，可省略参数标签
func sum(_ v1: Int, _ v2: Int) -> Int {
return v1 + v2;
}
// 调用函数
let result = sum(10, 20)
- 可添加参数标签
方便阅读
func gotowork(at time: String){
print("this time is \(time)")
}
gotowork(at: "08:00") //
func greet(person: String, from hometown: String) -> String {
return "Hello \(person)! Glad you could visit from \(hometown)."
}
print(greet(person: "Bill", from: "Cupertino"))
// 打印“Hello Bill! Glad you could visit from Cupertino.”
- 隐式返回
如果整个函数体是一个单一表达式，那么函数会返回这个表达式。
任何一个可以被写成一行 return 语句的函数，都可以忽略 return。
func sum(v1: Int, v2: Int) -> Int {
v1 + v2
}
sum(v1: 10, v2: 20)
- 返回元组：实现多返回值
func calculate(a : Int, b: Int) -> (sum: Int, subtract: Int, average: Int){
let v1 = a + b;
let v2 = a - b;
let v3 = v1 / 2
return (v1, v2, v3)
}
// 返回 可选类型的元组（可以为空）
// 加上 ？ 即可
func minMax(array: [Int]) -> (min: Int, max: Int)? {
if array.isEmpty { return nil } // 返回空
var currentMin = array[0]
var currentMax = array[0]
for value in array[1..<array.count] {
...
}
return (currentMin, currentMax)
}
- 传参默认值
func check(name: String = "Tom", age: Int = 12, job: String ) {
// do something
}
// 2种调用方式
check(job: "player")
check(name: "Alex", age: 30, job: "IT")
- 可变参数（可以传0个或多个值）
一个函数 最多只能有1个可变参数
紧跟在可变参数后面的参数 不能省略参数标签
通过在变量类型名后面加入...的方式，来定义可变参数。
func sum(_ numbers: Int...) -> Int {
var total = 0
// 此时参数numbers是一个数组，元素类型是Int
for num in numbers {
total += number
}
return total
}
sum(10, 20, 30, 40)
- 输入输出参数
在函数内部，可修改传参的值，本质是指针传递
用关键字
inout标记，调用时 传的是参数的地址，不能有默认值
可变参数不能标记为inout
func swapValues(v1: inout Int, v2: inout Int) {
let tmp = v1
v1 = v2
v2 = tmp
}
var num1 = 10
var num2 = 20
// 调用函数
swapValues(v1: &num1, v2: &num2)
函数重载(Function Overload)
函数名相同。参数个数不同 || 参数类型不同 || 参数标签不同
返回值类型与函数重载无关
内联函数(Inline Function)
如果开启了编译器优化(Release模式默认会开启优化)，编译器会自动将某些函数变成内联函数
- 函数类型
由函数的 形参类型、返回值类型组成
可将一个变量定义为 函数类型
用途：函数类型变量 可作为函数的参数、函数的返回值
// 无参无返回值的 函数类型为： () -> Void 或者 () -> ()
func test() { }
// 有参有返回值的 函数类型为： (Int, Int) -> Int
func sum(a: Int, b: Int) -> Int {
a+b
}
// 定义一个函数变量aafunc，变量值为 某个同类型的 函数
var aafunc: (Int, Int) -> Int = sum
// 调用时 不需要参数标签
aafun(2, 3) // 5，
函数类型变量，可作为另一个函数的 参数类型：
它不关心传入函数是如何实现的，只关心传入的函数是不是一个正确的类型。
// 接着上面的例子
func printMathResult(_ aafunc: (Int, Int) -> Int, _ a: Int, _ b: Int) {
print("Result: \(aafunc(a, b))")
}
// 调用时，传入一个函数
printMathResult(sum, 3, 5)
函数类型作为返回类型:
// 传入一个bool，返回一个函数
func chooseStepFunc(backward: Bool) -> (Int, Int) -> Int {
return backward ? xxxfunc : sum
}
- 嵌套函数
在一个函数的代码块内，可以定义一个函数；
把函数，定义在另一个函数的代码块内。
默认情况下，嵌套函数是对外界不可见的，但是可以被它们的外围函数（enclosing function）调用。一个外围函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用。
