Swift 函数 用来完成特定任务的独立的代码 块。 Swift 使用一个 统一的语法来表示简单的 C 语言风格的函数 到复杂的 Objective-C 语言风格的方法 :
Swift 函数 包含了参数类型及返回值类型。
Swift 定义函数 使用关键字 func,定义函数 的时候,可以指定一个 或多个输入参数和一个 返回值类型。 每个函数 都有一个 函数 名来描述它的功能 ,通过函数 名以及对应类型的参数值来调用 这个函数 ,函数 的参数传递的顺序必须与参数列表相同。 函数 的实参传递的顺序必须与形参列表相同,-> 后定义函数 的返回值类型。
func pi() -> Double {
return 3.1415
}
pi()
// 求和
//
// 将两个整数相加
// - Para meters:
// - v1: v1 第一个 整数
// - v2: v2 第二个整数
// - Returns: 2个整数的和
//
// - Note : 传入2个整数即可
func sum(v1: Int,v2: Int) -> Int {
v1 + v2
}
sum(v1: 10, v2: 20)
说明:
函数 名()的()里写的是参数,这里是虚参,也就是参数名称 ;
返回值是写在参数的后面,并且使用 -> 隔开,sum 函数 返回的是 Int 类型;
在 sum 函数 中我写了文档注释,这样便于后续维护,而且在调用 函数 时可以更加明确函数 的职责;
因为是单一的表达式,所以无需写 return,编译期会自动 判断。 注意:
若没有返回值有三种写法:返回 Void,Void 其实就是(),Void 是 () 空元祖的别名(注意 Void 的 V 是大写,跟其他语言不一样),返回(),也就是直接返回空元组 ;
如果整个函数 体只是简单的单一表达式,可以不写 return 来返回,编译器会自动 增加 return;
形参默 认是 let,也只能是 let,所以以后就不要写就行。
func calcula te(v1: Int,v2: Int) -> (sum: Int,diffence: Int,average: Int) {
let sum = v1+v2
return(sum,v1-v2,sum>>1)
}
let result = calcula te(v1: 20, v2: 10)
result.sum
result.diffence
result.average
result.0
result.1
result.2
说明:
函数 接收的时候就直接用一个 let 或 var 就行,因为是不确定数据类型的,所以可以接收任意类型;
接收后使用上就和正常的元组 一样,可以通过标识符取用,也可以使用下标取用。
Swift 有参数标签 这个东西,常见的参数名称 是为了在函数 内部有更好的语义化,而参数标签 是为了再外界调用 时有更好的语义化:
// 函数 标签 的案例
func goToWork(at time: String) {
// 内部语义化:this time is time
print("this time is \(time)")
}
goToWork(at: "08:00")
// 外部语义化:go to work at 08:00
// 省略参数标签
func sum(_ v1: Int, _ v2: Int) -> Int {
v1 + v2
}
sum(10, 20)
说明:
在函数 定义中使用的是 time 时间,这样更易读,this time is 08:00;
在函数 调用 时用 go to work at 08:00 这样来写更易读;
注意:
这种情况在调用 时就可以直接传值,如果是定义时不写参数标签 ,在外部调用 时仍然要写参数名称 ,而不能直接写参数。
② 默 认参数
func check(name: String = "nobody", age: Int,job: String = "none") -> () {
print("name=\(name),age=\(age),job=\(job)")
}
check(age: 18)
check(name: "wy", age: 18, job: "iOS")
check(age: 18,job: "iOS")
ame=nobody,age=18,job=none
name=wy,age=18,job=iOS
name=nobody,age=18,job=iOS
说明:
在函数 中 name 和 job 参数有自己的默 认参数值;
在调用 时函数 时可以不给 name 和 job 传值,函数 内部会使用默 认参数值来计算;
在传值时会使用到参数标签 所以不会有歧义,可以任意决定传值的参数,这与 C 语言不同。
③ 可变参数
在 Swift 中使用可变参数会很方便,当然了和其他语言一样其实在内部也是编译成一个 数组:
func sum(_ numbers: Int...) -> Int {
var total = 0
for number in numbers {
total += number
}
return total
}
sum(10,20,30,40)
sum(10, 20)
说明:
传入的参数中在数据类型的后面加上 …,这样就是可变参数;
紧跟在可变参数后面的参数不能省略参数标签 /参数名称 ,否则无法区分这个值是哪个参数的。
四、函数 内修改 外部变量的值(inout 的使用)
函数 的参数只能是常量,所以正常情况下无法修改 这个参数,如果想要修改 参数,就需要使用 inout 来修饰这个参数,这样做并且不仅可以修改 参数内部,还可以修改 外部的变量。本质是将值传递改为了指针传递。
// inout的使用
func swapValues(_ v1: inout Int, _ v2: inout Int) -> Void {
let tmp = v1
v1 = v2
v2 = tmp
}
var num1 = 10
var num2 = 20
swapValues(&num1, &num2) // 传入地址(其实就是指针,虽然Swift中没有指针变量的概念)
说明:
不同于其他语言,Swift 的虚参只能是常量,不能是变量,所以无法修改 ;
可以使用 inout 来修饰,就可以修改 外部变量的值;
调用 函数 时传入的值要传入变量地址,而不是变量本身;
函数 也有自己的数据类型,数据类型就是参数数据类型+返回值数据类型,这里的函数 类型可以视作 OC 中 block,在使用上和 block 基本一样,block 简单说来其实就是可作为变量/参数/返回值的能够捕获变量的匿名函数 ;如下所示,演示作为变量、参数、返回值的具体使用,可以看到和 block 的使用完全一致:
函数 的函数 类型就是参数数据类型+返回值数据类型;test() 函数 的函数 类型就是() -> ();test2() 函数 的数据类型为:(Int,String) -> (Int,Double)。
// 数据类型为:()->() 或者()->Void
func test() {
print("lalala")
}
// 数据类型为:(Int,String) -> (Int,Double)
func test2(a: Int,b: String) -> (Int,Double) {
return(7,7.0)
}
② 作为变量
定义一个 函数 类型的变量,就可以将这个函数 赋值给这个变量,之后通过这个变量来调用 函数 ; 通过函数 变量调用 时不需要参数标签 和参数名称 ,直接传值; 为更方便的说明,可以把定义变量和赋值参数分开写了,其实也可以写到一起。
//(Int,Int) -> Int
func sum2(a:Int,b:Int) -> Int {
a+b
}
// 1、通过函数 的数据类型定义一个 函数 变量
var fn: (Int,Int) -> Int;
// 2、赋值一个 函数
fn = sum2(a:b:)
// 3、调用
fn(2,3)
③ 作为参数传递
// 加法
func sum3(v1: Int, v2: Int) -> Int {
v1+v2
}
// 减法
func difference(v1: Int,v2: Int) -> Int {
v1-v2
}
// 通过传入的函数 和对变量进行对应的加减操作
// (Int, Int) -> Int 是mathFn参数的数据类型
func printResult(_ mathFn: (Int, Int) -> Int , _ a: Int, _ b:Int) {
print("Result: \(mathFn(a,b))")
}
printResult(sum, 20, 10)
printResult(difference, 20, 10)
在 printResult 函数 中第一个 参数就是一个 函数 ,这里传递到时候参数的数据类型就是函数 类型; (Int, Int) -> Int 是 mathFn 参数的数据类型; 在 PrintResult 函数 中就可以使用传入的函数 进行调用 了,通过传入的函数 和对变量进行对应的加减操作。
④ 作为返回值
// +1
func next(_ input: Int) -> Int {
input + 1
}
// -1
func prevIoU s(_ input: Int) -> Int {
input - 1
}
// 通过传入的Bool值判断返回哪个函数
// (Int) -> Int是返回值类型,是个函数 类型,因此返回函数
// 因为返回的是函数 所以只写名称 ,不需要带参数
func forward(_ forward: Bool) -> (Int) -> Int {
forward ? next : prevIoU s
}
forward(true)(3) // 4
forward(false)(4) // 2
forward 函数 的返回值类型是 (Int) -> Int,这是一个 函数 类型; 返回的是函数 所以只写名称 ,不需要带参数,如果带参数就是具体的值; forward(true) 得到的是函数 next,因此 next(3) 就是 4。
五、函数 的嵌套
import Cocoa
func calcDecrement(forDecrement total: Int) -> () -> Int {
var overallDecrement = 0
func decrementer() -> Int {
overallDecrement -= total
return overallDecrement
}
return decrementer
}
let decrem = calcDecrement(forDecrement: 30)
print(decrem())
-30