函数的定义
- 无返回值
func prinMethod(){
print("hello")
}
prinMethod()
- 有返回值
func pi() ->Double {
return 3.14
}
let num = pi()
print(num)
- 有参数有返回值
//形参默认是let，也只能是let
func sum(num1:Int ,num2:Int) ->Int {
return num1 + num2
}
let a = sum(num1:10,num2:20)
print(a)
隐式返回(Implicit Return)
- 如果整个函数体是一个单一表达式，那么函数会隐式返回这个表达式
func sum(num1:Int ,num2:Int) ->Int {
num1 + num2
}
返回元组:实现多返回值
func calculate(num1:Int,num2:Int) -> (sum:Int,difference:Int,average:Int){
let sum = num1 + num2
return (sum,num1 - num2,sum>>1)
}
let result = calculate(num1:4,num2:2)
print("和 \(result.sum)差 \(result.difference) 平均值\(result.average)")
参数标签(Argument Label)
- 可以修改参数标签
func goToWork(at time: String) {
print("this time is \(time)")
}
goToWork(at: "08:00")
// this time is 08:00
- 可以使用下划线_ 省略参数标签
func sum(_ v1: Int, _ v2: Int) -> Int {
v1 + v2
}
sum(10, 20)
默认参数值(Default Parameter Value)
- 参数可以有默认值
func check(name: String = "nobody", age: Int, job: String = "none") {
print("name=\(name), age=\(age), job=\(job)")
}
check(name: "Jack", age: 20, job: "Doctor") // name=Jack, age=20, job=Doctor
check(name: "Rose", age: 18) // name=Rose, age=18, job=none
check(age: 10, job: "Batman") // name=nobody, age=10, job=Batman
check(age: 15) // name=nobody, age=15, job=none
- C++的默认参数值有个限制:必须从右往左设置。由于Swift拥有参数标签，因此并没有此类限制
- 但是在省略参数标签时，需要特别注意，避免出错
// 这里的middle不可以省略参数标签
func test(_ first: Int = 10, middle: Int, _ last: Int = 30) { }
test(middle:20)
可变参数(Variadic Parameter)
func sum(_ numbers: Int...){
var total = 0;
for num in numbers {
total += num
}
print("和 \(total)")
}
sum(10,20,30,40)
print("2","3","4", separator:"\n")
- 一个函数最多只能有1个可变参数
- 紧跟在可变参数后面的参数不能省略参数标签
// 参数string不能省略标签
func test(_ numbers: Int..., string: String, _ other: String) { }
test(10, 20, 30, string: "Jack", "Rose")
Swift自带的print函数
/// - Parameters:
/// - items: Zero or more items to print.
/// - separator: A string to print between each item. The default is a single space (`" "`).
/// - terminator: The string to print after all items have been printed. The
/// default is a newline (`"\n"`).
public func print(_ items: Any..., separator: String = " ", terminator: String = "\n")
print(1, 2, 3, 4, 5) // 1 2 3 4 5
print(1, 2, 3, 4, 5, separator: "_") // 1_2_3_4_5
print("My name is Jake.", terminator: "")
print("My age is 18.")
// My name is Jake.My age is 18.
输入输出参数(In-Out Parameter)
可以用inout定义一个输入输出参数:可以在函数内部修改外部实参的值
var a = 10
func changeNum(_ num1: inout Int){
num1 = 20;
}
changeNum(&a)
print(a)
注意点
- 可变参数不能标记为inout
- inout参数不能有默认值
- inout参数只能传入可以被多次赋值的
- inout参数的本质是地址传递(引用传递)
函数重载(Function Overload)
规则
- 函数名相同
- 参数个数不同 || 参数类型不同 || 参数标签不同
func sum(v1: Int, v2: Int) -> Int {
v1 + v2
}
// 参数个数不同
func sum(v1: Int, v2: Int, v3: Int) -> Int {
v1 + v2 + v3
}
// 参数类型不同
func sum(v1: Int, v2: Double) -> Double {
Double(v1) + v2
}
// 参数类型不同
func sum(v1: Double, v2: Int) -> Double {
v1 + Double(v2)
}
// 参数标签不同
func sum(_ v1: Int, _ v2: Int) -> Int {
v1 + v2
}
// 参数标签不同
func sum(a: Int, b: Int) -> Int {
a+b
}
sum(v1: 10, v2: 20) // 30
sum(v1: 10, v2: 20, v3: 30) // 60
sum(v1: 10, v2: 20.0) // 30.0
sum(v1: 10.0, v2: 20) // 30.0
sum(10, 20) // 30
sum(a: 10, b: 20) // 30
函数重载注意点
- 返回值类型与函数重载无关
func sum(v1: Int, v2: Int) -> Int { v1 + v2 }
func sum(v1: Int, v2: Int) { }
//Ambiguous use of 'sum(v1:v2)'
- 默认参数值和函数重载一起使用产生二义性时，编译器并不会报错(在C++中会报错)
func sum(v1: Int, v2: Int) -> Int {
v1 + v2
}
func sum(v1: Int, v2: Int, v3: Int = 10) -> Int {
v1 + v2 + v3
}
// 会调用sum(v1: Int, v2: Int)
sum(v1: 10, v2: 20)
- 可变参数、省略参数标签、函数重载一起使用产生二义性时，编译器有可能会报错
func sum(v1: Int, v2: Int) -> Int {
v1 + v2
}
func sum(_ v1: Int, _ v2: Int) -> Int {
v1 + v2
}
func sum(_ numbers: Int...) -> Int {
var total = 0
for number in numbers {
total += number
}
return total
}
// error: ambiguous use of 'sum'
sum(10, 20)
内联函数(Inline Function)
- 如果开启了编译器优化(Release模式默认会开启优化)，编译器会自动将某些函数变成内联函数
- 将函数调用展开成函数体
哪些函数不会被自动内联?
- 函数体比较长
- 包含递归调用
- 包含动态派发
- ...
@inline
// 永远不会被内联(即使开启了编译器优化)
@inline(never) func test() {
print("test")
}
// 开启编译器优化后，即使代码很长，也会被内联(递归调用函数、动态派发的函数除外)
@inline(__always) func test() {
print("test")
}
- 在Release模式下，编译器已经开启优化，会自动决定哪些函数需要内联，因此没必要使用@inline
函数类型(Function Type)
- 每一个函数都是有类型的，函数类型由形式参数类型、返回值类型组成
函数作为类型
func test() { } // () -> Void 或者 () -> ()
func sum(a: Int, b: Int) -> Int {
a+b
} // (Int, Int) -> Int
// 定义变量
var fn: (Int, Int) -> Int = sum
fn(2, 3) // 5，调用时不需要参数标签
函数类型作为函数参数
func sum (num1:Int ,num2:Int) -> Int {
num1 + num2
}
func difference (num1:Int ,num2:Int) -> Int {
num1 - num2
}
func printResult(_ mathFn:(Int ,Int) -> Int ,_ a:Int ,_ b:Int){
print("result \(mathFn(a,b))")
}
printResult(sum, 2, 1)
printResult(difference, 2, 1)
函数作为返回值
func next (_ a:Int) -> Int{
a + 1
}
func previous (_ a:Int) -> Int{
a - 1
}
func forward(_ flag:Bool) -> (Int)->Int {
flag ? next : previous
}
let a = forward(false)(3)
print(a)
- 返回值是函数类型的函数，叫做高阶函数(Higher-Order Function)
typealias
typealias Date = (year:Int,month:Int,day:Int)
func getTime(_ date:Date){
print("年:\(date.year) 月:\(date.month) 日:\(date.day) ")
}
getTime((2010,9,19))
typealias IntFn = (Int,Int) -> Int
func difference(v1:Int,v2:Int) -> Int {
v1 - v2
}
let fn:IntFn = difference
let a = fn(4,2)
print(a)
func setFn(_ fn:IntFn){}
setFn(difference)
func getFn() ->IntFn {
difference
}
let fbs = getFn()
let a = fbs(2,1)
print(a)
- 按照Swift标准库的定义，Void就是空元组()
public typealias Void = ()
嵌套函数
func forward(_ flag:Bool) -> (Int) -> Int {
func next(_ input:Int) -> Int {
input + 1
}
func previous(_ input:Int) -> Int {
input - 1
}
return flag ? next : previous
}
let a = forward(false)(3)
print(a)
