案例代码下载

函数

Swift中的每个函数都有一个类型，由函数的参数类型和返回类型组成。像Swift中的任何其他类型一样使用此类型，这使得将函数作为参数传递给其他函数以及从函数返回函数变得很容易。函数也可以在其他函数中编写，以在嵌套函数范围内封装有用的功能。

定义和调用函数

略……

函数参数标签和参数名称

参数标签

每个函数参数都有参数标签和参数名称。调用函数时使用参数标签; 每个参数都在函数调用时写入，其前面带有参数标签。参数名称用于函数的实现。默认情况下，参数使用其参数名称作为其参数标签。

所有参数必须具有唯一名称。虽然多个参数可能具有相同的参数标签，但唯一的参数标签有助于使您的代码更具可读性。

参数名称前面编写参数标签，用空格分隔：

func someFunc(argumentLabel argumentName: Int) {
    print(argumentName)
}
someFunc(argumentLabel: 1)

不想要参数的参数标签，请为该参数编写下划线（_）而不是显式参数标签:

func otherFunc(_ argumentName1: Int, argumentLabel2 argumentName2: Int) {
    print("\(argumentName1) + \(argumentName2) = \(argumentName1 + argumentName2)")
}
otherFunc(1, argumentLabel2: 2)

默认参数

在参数的类型之后为参数赋值来为函数中的任何参数定义默认值。如果定义了默认值，则可以在调用函数时省略该参数:

func defaultParameterFunc(argument1: Int = 1, argument2: Int) {
    print("\(argument1) + \(argument2) = \(argument1 + argument2)")
}
defaultParameterFunc(argument2: 3)
defaultParameterFunc(argument1: 2, argument2: 2)

可变参数

变参数参数接受具有指定类型的零倍或更多的值。使用可变参数指定在调用函数时可以为参数传递不同数量的输入值。通过在参数的类型名称后面插入三个句点字符（...）来编写可变参数。

可变参数的值在函数体内可用作适当类型的数组。函数可以具有至多一个可变参数。

func variadicParameterFunc(nums: Int...) {
    let sum = nums.reduce(0) { (result, num) -> Int in
        return result + num
    }
    print("\(nums) 的和: \(sum)")
}
variadicParameterFunc(nums: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

输入输出参数

默认情况下，函数参数是常量。尝试从该函数体内更改函数参数的值会导致编译时错误。这意味着无法更改参数的值。

通过将inout关键字放在参数类型之前来编写输入输出参数。一个输入输出参数传递进函数的值，可以由函数修改并替换原来的值。

将变量作为输入输出参数的参数传递。不能传递常量或文字值作为参数，因为不能修改常量和文字。当使用输入输出参数调用函数时在变量的名称前直接放置一个&，以指示该函数可以修改它。

输入输出参数不能具有默认值，并且可变参数不能标记为inout。

func inoutFunc(argument1: inout Int, argument2: inout Int) {
    let temp = argument1
    argument1 = argument2
    argument2 = temp
}
var inout1 = 1
var inout2 = 2
inoutFunc(argument1: &inout1, argument2: &inout2)
print("inout1: \(inout1), inout2: \(inout2)")

函数类型

每个函数都有一个特定的函数类型，由函数的参数类型和返回类型组成。形式上表示为：(参数类型) -> 返回值类型。

使用函数类型

像使用Swift中的任何其他类型一样使用函数类型。例如，可以将常量或变量定义为函数类型，并为该变量分配适当的函数：

func addInts(nums: [Int]) -> Int {
    return nums.reduce(0) { (result, item) -> Int in
        return result + item
    }
}
func multiplyInts(nums: [Int]) -> Int {
    return nums.reduce(1, { (result, item) -> Int in
        return result*item
    })
}
var mathFunc: ([Int]) -> Int = addInts(nums:)
print(mathFunc([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))
mathFunc = multiplyInts(nums:)
print(mathFunc([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))

函数类型作为参数类型

可以使用函数类型，作为另一个函数的参数类型。这使得可以为函数调用者保留函数实现的某些方面，以便在调用函数时提供：

func printMathResult(mathFunc: ([Int]) -> Int, nums: Int...) {
    print("用参数\(nums)执行函数\(mathFunc)的结果是：\(mathFunc(nums))")
}
printMathResult(mathFunc: mathFunc, nums: 1, 2, 3, 4, 5)

函数类型作为返回类型

可以使用函数类型作为另一个函数的返回类型。通过在返回函数的返回箭头（->）之后立即编写完整的函数类型来完成此操作:

func chooseFunc(addInts: Bool) -> ([Int]) -> Int {
    return addInts ? addInts(nums: ) : multiplyInts(nums:)
}
print(chooseFunc(addInts: true)([1, 2, 3, 4, 5]))

嵌套函数

在函数体内定义的函数称为嵌套函数，嵌套函数对外界是隐藏的，但它们的封闭函数仍然可以调用它们。封闭函数也可以返回其嵌套函数，以允许嵌套函数在另一个范围内使用：

func sumFunc() -> (Int...) -> Int {
    func sumInts(nums: Int...) -> Int {
        return nums.reduce(0) { (result, item) -> Int in
            result + item
        }
    }
    
    return sumInts(nums:)
}
print(sumFunc()(1, 2, 3, 4, 5))