1.基本内容
func greet(person: String) -> String {
let greeting = "Hello, " + person + "!"
return greeting
}
(1) func 作为前缀
(2) 函数的名字是greet(person:)
(3) 需输入一个String类型的参数
(4) 指定函数返回类型是String,用返回箭头 ->(一个连字符后跟一个右尖括号)后跟返回类型的名称的方式来表示。如果函数不需要返回值,就不要写返回箭头(->)和返回类型。
函数被调用:
print(greet(person: "Anna"))
// 打印 "Hello, Anna!"
2.多重返回值函数
(1)用元组(tuple)类型让多个值作为一个复合值从函数中返回。
func minMax(array: [Int]) -> (min: Int, max: Int) {
var currentMin = array[0]
var currentMax = array[0]
for value in array[1..<array.count] {
if value < currentMin {
currentMin = value
} else if value > currentMax {
currentMax = value
}
}
return (currentMin, currentMax)
}
minMax(array:) 函数返回一个包含两个 Int 值的元组,这些值被标记为 min 和 max ,以便查询函数的返回值时可以通过名字访问它们。
因为元组的成员值已被命名,因此可以通过 . 语法来检索找到的最小值与最大值:
let bounds = minMax(array: [8, -6, 2, 109, 3, 71])
print("min is \(bounds.min) and max is \(bounds.max)")
// 打印 "min is -6 and max is 109"
(2)可选元组返回类型
返回的元组类型有可能整个元组都“没有值”,可以使用可选的( optional ) 元组。例如:(Int, Int)?
func minMax(array: [Int]) -> (min: Int, max: Int)? {
……
return (currentMin, currentMax)
}
把 minMax(array:) 函数改写为使用可选元组返回类型,可以安全处理传入的参数是“空”的问题。
可以使用可选绑定来检查 minMax(array:) 函数返回的是一个存在的元组值还是 nil:
if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
print("min is \(bounds.min) and max is \(bounds.max)")
}
// 打印 "min is -6 and max is 109"
3. 函数参数标签
(1)指定参数标签
你可以在函数名称前指定它的参数标签,中间以空格分隔:
func someFunction(argumentLabel parameterName: Int) {
// 在函数体内,parameterName 代表参数值,argumentLabel为参数标签
}
所有的参数都必须有一个独一无二的名字。虽然多个参数拥有同样的参数标签是可能的,但是一个唯一的函数标签能够使你的代码更具可读性。
(2)忽略参数标签
如果不希望为某个参数添加一个标签,可以使用一个下划线(_)来代替一个明确的参数标签。
func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
// 在函数体内,firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值
}
someFunction(1, secondParameterName: 2)
如果一个参数有一个标签,那么在调用的时候必须使用标签来标记这个参数。
4.参数
(一)默认参数值
(1)
func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
// 如果你在调用时候不传第二个参数,parameterWithDefault 会值为 12 传入到函数体中。
}
(2)可变参数
一个可变参数(variadic parameter)可以接受零个或多个值。通过在变量类型名后面加入(…)的方式来定义可变参数。
可变参数的传入值在函数体中变为此类型的一个数组。
一个函数最多只能拥有一个可变参数。
func arithmeticMean(_ numbers: Double...) -> Double { // 传入numbers 的 [Double] 型的数组常量。
var total: Double = 0
for number in numbers {
total += number
}
return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)
// 返回 3.0, 是这 5 个数的平均数。
arithmeticMean(3, 8.25, 18.75)
// 返回 10.0, 是这 3 个数的平均数。
(二)输入输出参数
(1)函数参数默认是常量。
(2)不能错误地更改参数值。
(3)如果把某个函数的参数定义为输入输出参数(In-Out Parameters),那么该函数可以修改参数的值,并且修改后的结果在函数调用结束后仍然存在。
(4)定义一个输入输出参数时,在参数定义前加 inout 关键字。一个输入输出参数有传入函数的值,这个值被函数修改,然后被传出函数,替换原来的值。
(5)只能传递变量给输入输出参数,不能传递常量。
(6)当传入的参数作为输入输出参数时,需要在参数名前加 & 符,表示这个值可以被函数修改。
(7)输入输出参数不能有默认值,而且可变参数不能用 inout 标记。
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
let temporaryA = a
a = b
b = temporaryA
}
var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
// 打印 "someInt is now 107, and anotherInt is now 3"
5.使用函数类型
var mathFunction: (Int, Int) -> Int = addTwoInts
定义一个叫做 mathFunction 的变量,其类型为(Int, Int) -> Int,新变量指向 addTwoInts 函数(addTwoInts 函数符合(Int, Int) -> Int)。
可以用 mathFunction 来调用被赋值的函数了:
print("Result: \(mathFunction(2, 3))")
// Prints "Result: 5"
(1)函数类型作为参数类型
func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
print("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// 打印 "Result: 8"
// 函数的参数有:
// 1.(Int, Int) -> Int型的mathFunction
// 2. Int型的a
// 3. Int型的b
// 调用时,传入 addTwoInts 函数和整数 3 和 5
(2)函数类型作为返回类型
func stepForward(_ input: Int) -> Int {
return input + 1
}
func stepBackward(_ input: Int) -> Int {
return input - 1
}
func chooseStepFunction(backward: Bool) -> (Int) -> Int {
// chooseStepFunction函数的返回类型是,类型为(Int) -> Int的函数
return backward ? stepBackward : stepForward
// stepBackward 和 stepForward函数的类型都为(Int) -> Int
}