函数
函数结构
func关键词 + 函数名 + 形式参数 + "->"(表示返回) + 返回类型
func sum(number1:Int, numbe2:Int) -> Int {
number + number // 单一表达式，可省略关键词return
}
备注：
当函数体位单一表达式是，可以省略关键词return，表示直接返回该单一表达式的值
无返回值
无返回值总共有三种写法。
/**
* 方式1：直接不写返回类型
*/
func voidFunc1() {
print(111)
}
/**
* 方式2：返回Void
*/
func voidFunc2() -> Void {
print(222)
}
/**
* 方式3：返回空元组()
*/
func voidFunc3() -> () {
print(333)
}
备注：
实际上Swift定义中，Void为即为空元组()
// 官方解释
public typealias Void = ()
返回多个值
swift中允许返回多个值，利用元组即可
/**
* 例子1：不含标签的元组返回
*/
func networkStatus() -> (Int, String) {
(404, "Not Found") // 方式1
// (status:404, msg:"Not Found") // 方式2
}
print(networkStatus())
// 结果：(404, "Not Found") [无论方式1 or 方式2都一样]
/**
* 例子2：含标签的元组返回
*/
func sumAndAvg(number1:Double, number:Double) -> (sum:Double, avg:Double) {
let sum = number1 + number2
let avg = sum / 2.0
return (sum:sum, avg:avg)
}
print(sumAndAvg(number1: 1.1, number2:5.1))
// 结果：(sum:6.2, avg:3.1)
修改标签
swift提倡代码的阅读星，因此允许修改标签。
即对外使用最前面的标签，对里使用最后面的标签。且只允许同时并存使用两个标签
func work(at time:Int) {
// 为了语time？""
print("It's \(time) o'clock.It's time to work")
}
work(at: 9) // 为了语义通顺，用at
inout参数（引用传递）
var numner = 10
func increaseNumber(number:inout Int) {
number += 1
}
increaseNumber(number: &number)
print(number)
// 结果：11
Inout 关键词只能用于允许允许修改的容易，如var。而像let这种是不允许进行修改的。
1. 例子
交换两个值的方式
var number1 = 1
var number2 = 2
// 方法1：用inout参数+中间变量
func exchange(_ v1:inout Int, _ v2:inout Int) {
le tem = v1
v1 = v2
v2 = tem
}
exchange(&number1, &number2)
// 方式2：用inout参数+元组(这个方式比较巧)
func exchange(_ v1:inout Int, _ v2:inout Int) {
(v2, v1) = (v1, v2)
}
// 方式3：用官方自带API
swap(&number1, &number2)
可变参数
func customPrint(_ intNum:Int...) {
print(intNum)
}
customPrint(1, 2, 3, 4)
注意点：
可变参数后面的参数标签不可省略
/**
* 示范：在可变参数后面的参数标签不可省略
*/
func customPrint(sequeue:Int..., name:String) { // name标签不可省略
print(sequeue, name)
}
customPrint(sequeue:1,2,3,4, name:""66666)
// 结果：1 2 3 4 6666
函数重载
跟Java的重载概念一致。
重载规则：
-
参数类型不同
-
参数个数不同
-
参数便签名称不同
/**
* 示范：参数类型不同
*/
func sum(v1:Double, v2:Int) -> Int {
Int(v1) + v2
}
func sum(v2:Int, v3:Int) -> Int {
v2 + v3
}
/**
* 示范：参数个数不同
*/
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:Int) -> Int {
v1 + v2
}
func sum(v2:Int, v3:Int) -> Int {
v2 + v3
}
注意：
返回类型不能作为重载的依据（由于在调用的时候，编译会混淆，不知道该调用哪个函数）
func sum(_ v1:Int, _ v2:Int) -> Int {
v1 + v2
}
func sum(_ v1:Int, _ v2:Int) -> Double {
Double(v1 + v2)
}
// 无法编译通过，会有歧义
高阶函数
在返回结果值为另一个函数的函数称为高阶函数
/**
* 高阶函数
*/
// 此处(Int) -> Int 为该walk函数的返回值
func walk(_ isForward:Bool) -> ((Int) -> Int) {
isForward ? forward: back
}
func forward(step:Int) -> Int {
return step
}
func back(step:Int) -> Int {
return -step
}
// 调用方式1
print(walk(false)(1))
// 调用方式2
var customForward = walk(false)
print(customForward(1))
注意：
函数返回值不允许带有标签。就算是函数类型的结果值也不予许带
/**
* 错误释放
*/
// (Int) -> Int 不予许变成 (step:Int) -> Int。函数返回值不允许带标签
func walk(_ isForward:Bool) -> ((step:Int) -> Int) {
isForward ? forward: back
}
func forward(step:Int) -> Int {
return step
}
func back(step:Int) -> Int {
return -step
}
嵌套函数
函数内嵌套函数
func walk(isForward:Bool, step:Int) {
func fowrd(_ step:Int) {
print(step)
}
func back(_ step:Int) {
print(step)
}
isForward ? forward(step) : back(step)
}
walk(isForward:true, step:1)
// 结果：1
网友评论