Swift 定义函数使用关键字 func,可以指定0+个输入参数和一个返回值类型。
Swift屏蔽了指针，但是传递class时使用的是引用方式，其他类型如Int,struct,enum等均是传值方式。语法：
1.函数定义
func funcName(avgs...) -> ReturnType {
Statement1
Statement2
……
Statement N
return parameters
}
2.函数调用
我们可以通过函数名以及对应类型的参数值来调用函数，函数的参数传递的顺序必须与参数列表相同。
// 定义了名为 eat 的函数，形参的数据类型为 String，返回值也为 String：
func eat(food: Any) -> String {
return food
}
print(eat(food: "apple"))
3. 函数参数
函数可以接受0+个参数，这些参数被包含在函数的括号之中，以逗号分隔。
func test(name: String, age: String) -> String {
return name + " " + age
}
let res = test(name: "Monkey", age: 12) // "Monkey 12"
4.无参函数
我们可以创建不带参数的函数,计算属性就是一个无参函数。
// 无参函数
func funcName() -> T {
return T
}
// 计算属性
var caculateProperty: T {
return T
}
5.局部参数名
局部参数名在函数的实现内部使用。
func sample(number: Int) {
print(number)
}
sample(number: 1) // 1
sample(number: 2) // 2
sample(number: 3) // 3
6.外部参数名
你可以在局部参数名前指定外部参数名，中间以空格分隔，外部参数名用于在函数调用时传递给函数的参数。
func pow(firstArg a: Int, secondArg b: Int) -> Int {
var res = a
for _ in 1..<b {
res = res * a
}
print(res)
return res
}
pow(firstArg:5, secondArg:3) // 125
你也可以使用_作为外部变量名，那么在调用的时候可以省去外部变量名，像一个c函数的参数那样
func pow(_ a: Int, _ b: Int) -> Int {
var res = a
for _ in 1..<b {
res = res * a
}
print(res)
return res
}
pow(5,3) // 125
注意
如果你提供了外部参数名，那么函数在被调用时，必须使用外部参数名。
7.可变参数
可变参数可以接受零个或多个值。函数调用时，你可以用可变参数来指定函数参数，其数量是不确定的。 可变参数通过在变量类型名后面加入...的方式来定义。
func vari<N>(members: N...){
for i in members {
print(i)
}
}
vari(members: 4,3,5)
vari(members: 4.5, 3.1, 5.6)
vari(members: "Google", "Baidu")
// 4
// 3
// 5
// 4.5
// 3.1
// 5.6
// Google
// Baidu
8.常量，变量及 I/O 参数
一般默认在函数中定义的参数都是常量参数，也就是这个参数是只读的。如果想要声明一个变量参数，可以在参数定义前加 inout 关键字，这样就可以改变这个参数的值了(用法和OC相同，传参前加上&)。
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
let temporaryA = a
a = b
b = temporaryA
}
var x = 1
var y = 5
swapTwoInts(&x, &y)
print("x 现在的值 \(x), y 现在的值 \(y)") // x 现在的值 5, y 现在的值 1
9. 函数类型及使用
每个函数都有种特定的函数类型，由函数的参数类型和返回类型组成。
func inputs(no1: Int, no2: Int) -> Int {
return no1 / no2
}
print(inputs(no1: 20, no2: 10)) // 2
print(inputs(no1: 36, no2: 6)) // 6
在 Swift 中，使用函数类型就像使用其他类型一样。例如，你可以定义一个类型为函数的常量或变量，并将适当的函数赋值给它：
// 定义一个叫做 addition 的变量，参数与返回值类型均是 Int ，并让这个新变量指向 sum 函数
var addition: (Int, Int) -> Int = sum
// sum 和 addition 有同样的类型，所以以上操作是合法的。
// 现在，你可以用 addition 来调用被赋值的函数了：
func sum(a: Int, b: Int) -> Int {
return a + b
}
var addition: (Int, Int) -> Int = sum
print("输出结果: \(addition(40, 89))") // 129
函数类型作为参数类型、函数类型作为返回类型, 我们可以将函数作为参数传递给另外一个参数：
func sum(a: Int, b: Int) -> Int {
return a + b
}
var addition: (Int, Int) -> Int = sum
print("输出结果: \(addition(40, 89))") // 129
func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
print("输出结果: \(addition(a, b))")
}
another(addition: sum, a: 10, b: 20) // 30
10.函数嵌套
函数嵌套指的是函数内定义一个新的函数，外部的函数可以调用函数内定义的函数。
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
当然函数里面也可以像OC一样定义一个block使用
func calcDecrement(forDecrement total: Int) -> () -> Int {
var overallDecrement = 0
let decrementer = { () -> Int in
overallDecrement -= total
return overallDecrement
}
return decrementer()
}
let decrem = calcDecrement(forDecrement: 30)
print(decrem()) //-30
网友评论