基础语法-函数
函数
func pi() -> Double{
return 3.14
}
func sum(v1: Int, v2: Int) -> Int {
return v1 + v2
}
sum(v1: 10, v2: 20)
形参默认是let，也只能是let
无返回值
func sayHello() -> Void {
print("Hello")
}
func sayHello1() -> () {
print("Hello")
}
func sayHelo2() {
print("Hello")
}
隐式返回（Implicit Return）
如果整个函数体是一个单一的表达式，那么函数会隐式返回这个表达式
func sum(v1: Int, v2: Int) -> Int {
v1+v2
}
sum(v1: 10, v2: 20)
返回元组：实现多返回值
func calculate(v1: Int, v2: Int) -> (sum: Int, difference: Int, average: Int) {
let sum = v1 + v2
return (sum, v1 - v2, sum >> 1)
}
let result = calculate(v1: 20, v2: 10)
result.sum
result.difference
result.average
函数的文档注释
/求和【概述】
/
/ - Parameters:
/ - v1: 第一个整数
/ - v2: 第二个整数
/ - Returns: 2个整数的和
/
/ - Note: 传入2个整数即可【批注】
func sum(v1: Int, v2: Int) -> Int {
return v1 + v2
}
sum(v1: 10, v2: 20)
//参考：https://swift.org/documentation.api-design-guidelines/
参数标签
可以修改参数标签
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 {
return v1 + v2
}
sum( 10, 20)
默认参数值
参数是可以有默认值的
func check(name: String = "nobody", age: Int, job: String = "none") {
print("name=\(name), age=\(age), job=\(job)")
}
check(name: "Jack", age: 20, job: "Doctor")
check(name: "Rose", age: 18)
check(age: 10, job: "Batman")
check(age: 15)
//name=Jack, age=20, job=Doctor
//name=Rose, age=18, job=none
//name=nobody, age=10, job=Batman
//name=nobody, age=15, job=none
C++的默认参数值有个限制：必须从右往左设置。由于Swift拥有参数标签，因此并没有此类限制
在省略参数标签的时候，需要特别注意，避免出错
可变参数
func sum(_ numbers: Int...) -> Int {
var total = 0
for number in numbers {
total += number
}
return total
}
sum(10, 20, 30, 40) //100
一个函数最多只能有1个可变参数
紧跟在可变参数后面的参数不能省略参数标签
func test(_ numbers: Int..., string: String, _ other: String){}
test(10, 20, 30, string:"Jack", "Rose")
func test(_ other: String, _ numbers: Int..., string: String){
print(other)
}
test("1", 10, 20, 30, string:"Jack")
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")//1 2 3 \n
print("1", "2", "3", separator: "", terminator: "")//12320
print(20);
输入输出
可以用inout定义一个输入输出参数：可以在函数内部修改外部实参的值
var number = 10
func add(_ num: inout Int) {
num += 1
}
add(&number)
print(number)//11
func swapValues(_ v1: inout Int, _ v2: inout Int) {
let tmp = v1
v1 = v2
v2 = tmp
}
var num1 = 10
var num2 = 20
swapValues(&num1, &num2)
func swapValues(_ v1: inout Int, _ v2: inout Int) {
(v1, v2) = (v2, v1)
}
可变参数不能标记为inout（带...的）
inout参数不能有默认值
inout参数的本质是地址传递（引用传递&）用汇编验证
inout参数只能传入可以被多次赋值的
函数重载
规则
函数名相同
参数个数不同||参数类型不同||参数标签不同
func sum(v1: Int, v2: Int) -> Int {
return v1 + v2
}
func sum(v1: Int, v2: Int, v3: Int) -> Int {
return v1 + v2 + v3
}//参数个数不同
func sum(v1: Int, v2: Double) -> Double {
return Double(v1) + v2
}//参数类型不同
func sum(_ v1: Int, _ v2: Int) -> Int {
return v1 + v2
}//参数标签不同
func sum(a: Int, b: Int) -> Int {
return a + b
}//参数标签不同
返回类型与函数重载无关
func sum(v1: Int, v2: Int) -> Int { v1 + v2 }
func sum(v1: Int, v2: Int) {}
sum(v1: 10, v2: 20)//Ambiguous use of 'sum(v1:v2:)'
默认参数值和函数重载一起使用产生二义性时，编译器并不会报错（在C++中会报错）
func sum(v1: Int, v2: Int) -> Int {
return v1 + v2
}
func sum(v1: Int, v2: Int, v3: Int = 10) -> Int {
return v1 + v2 + v3
}
sum(v1: 10, v2: 20)//会调用sum(v1: Int, v2: Int)
可变参数，省略参数标签，函数重载一起使用产生二义性时，编译器有可能会报错
func sum(v1: Int, v2: Int) -> Int {
return v1 + v2
}
func sum(_ v1: Int, _ v2: Int) -> Int {
}
func sum(_ numbers: Int...) -> Int {
var total = 0
for number in numbers {
total += number
}
return total
}
sum(10, 20)//Ambiguous(奇异) use of 'sum'、
内联函数
如果开起来编译器优化（Release模式默认会开启优化），编译器会自动将某些函数变成内联函数
设置：build settings -> Optimization Level
将函数展开成函数体（汇编验证）
Swift也是有main函数的，不用我们写
func test() {
print("test123")
}
优化后print("test123")
哪些函数不会被内联？
1. 函数体比较长的（生成的汇编代码长，包体积大）
2. 包含递归调用
3. 包含动态派发（子类和父类有相同方法名时编译时不确定调用哪个函数就是多态的时候）
@inline
永远不会被内联（即使开启了编译器优化）
@inline(never) func test() {
print("test")
}
开启编译器优化后，即使代码很长，也会被内联（递归调用函数，动态派发的函数除外）
@inline(__always) func test() {
print("test")
}
在release模式下，编译器已经开启优化，会自动觉得那些函数需要内联，因此没必要使用@inline
函数类型
每一个函数都是有类型的，函数类型有 形式参数类型，返回值类型 组成
func test() {}
func sum(a: Int, b: Int) -> Int {
return a + b
}// (Int, Int) -> Int
//定义变量
var fn: (Int, Int) -> Int = sum
fn(2, 3)// 5 (调用时不需要参数标签)
函数类型作为函数参数
func sum(v1: Int, v2: Int) -> Int {
return v1 + v2
}
func difference(v1: Int, v2: Int) -> Int {
return v1 - v2
}
func printResult(_ mathFn: (Int, Int) -> Int, _ a: Int, _ b: Int) {
print("Result: \(mathFn(a, b))")
}
printResult(sum, 5, 2)
printResult(difference, 5, 2)
函数类型作为函数返回值
func next(_ input: Int) -> Int {
return input + 1
}
func previous(_ input: Int) -> Int {
return input - 1
}
func forward(_ forward: Bool) -> (Int) -> Int {
return forward ? next : previous
}//(Int) -> Int为返回函数
forward(true)(3)
forward(false)(3)
返回值是函数类型的函数，叫做高阶函数
typealias
用来给类型起别名
typealias Byte = Int8
typealias Short = Int16
typealias Long = Int64
typealias Date = (year: Int, month: Int, day: Int)
func test(_ date: Date) {
print(date.0)
print(date.year)
}
test((2011, 9, 10))
typealias IntFn = (Int, Int) -> Int
func difference(v1: Int, v2: Int) -> Int {
return v1 - v2
}
let fn: IntFn = difference
fn(20, 10)
func setFn(_ fn: IntFn){}
setFn(difference)
func getFn() -> IntFn {
return difference
}
按照Swift标准库的定义，Void就是空元组（）
func test () -> Void {
}//public typealias Void = ()
嵌套函数
将函数定义在函数内部
func forward(_ forward: Bool) -> (Int) -> Int {
func next(_ input: Int) -> Int {
return input + 1
}
func previous(_ input: Int) -> Int {
return input - 1
}
return forward ? next : previous
}//(Int) -> Int为返回函数
forward(true)(3)
forward(false)(3)
