Swift学习笔记 (十四) 函数(上)

函数是一段完成特定任务的独立代码片段。你可以通过给函数命名来标识某个函数的功能，这个名字可以被用来在需要的候“调

用”这个函数来完成它的任务。

Swift 统一的函数语法非常的灵活，可以用来表示任何函数，包括从最简单的没有参数名字的 C 风格函数，到复杂的带局部和外

部参数名的 Objective-C 风格函数。参数可以提供默认值，以简化函数调用。参数也可以既当做传入参数，也当做传出参数，也

就是说，一旦函数执⾏结束，传入的参数值将被修改。

在 Swift 中，每个函数都有一个由函数的参数值类型和返回值类型组成的类型。你可以把函数类型当做任何其他普通变量类型一

样处理，这样就可以更简单地把函数当做别的函数的参数，也可以从其他函数中返回函数。函数的定义可以写在其他函数定义

中，这样可以在嵌套函数范围内实现功能封装。

 

函数的定义与调⽤

当你定义一个函数时，你可以定义一个或多个有名字和类型的值，作为函数的输入，称为参数，也可以定义某种类型的值作为函

数执⾏结束时的输出，称为返回类型。

每个函数有个函数名，用来描述函数执⾏的任务。要使用一个函数时，⽤函数名来“调用”这个函数，并传给它匹配的输入值(称

作实参)。函数的实参必须与函数参数表⾥参数的顺序一致。

下⾯例子中的函数的名字是 greet(person:) ，之所以叫这个名字，是因为这个函数⽤一个人的名字当做输入，并返回向这个⼈问

候的语句。为了完成这个任务，你需要定义一个输入参数——一个叫做 person 的 String 值，和一个包含给这个人问候语的 

String 类型的返回值:

func greet(person: String) -> String {

          let greeting = "Hello, " + person + "!"

          return greeting

}

所有的这些信息汇总起来成为函数的定义，并以 func 作为前缀。指定函数返回类型时，用返回箭头 -> (一个连字符后跟一个右

尖括号)后跟返回类型的名称的方式来表示。

该定义描述了函数的功能，它期望接收什么作为参数和执⾏结束时它返回的结果是什么类型。这样的定义使得函数可以在别的地

方以⼀种清晰的方式被调用:

print(greet(person: "Anna"))

// 打印“Hello, Anna!”

print(greet(person: "Brian"))

// 打印“Hello, Brian!”

调用 greet(person:) 函数时，在圆括号中传给它一个 String 类型的实参，例如 greet(person: "Anna") 。正如上面所示，因为这个

函数返回一个 String 类型的值，所以 greet 可以被包含在 print(_:separator:terminator:) 的调用中，用来输出这个函数的返回值。

注意

print(_:separator:terminator:) 函数的第一个参数并没有设置一个标签，⽽其他的参数因为已经有了默认值，因此是可选的。关

于这些函数语法上的变化详见下方关于函数参数标签和参数名以及默认参数值。

在 greet(person:) 的函数体中，先定义了一个新的名为 greeting 的 String 常量，同时，把对 personName 的问候消息赋值给了 

greeting 。然后用 return 关键字把这个问候返回出去。一旦 return greeting 被调用， 该函数结束它的执⾏并返回 greeting 的当

前值。

你可以用不同的输入值多次调用 greet(person:) 。上⾯的例子展示的是用 "Anna" 和 "Brian" 调用的结果，该函数分别返回了不同

的结果。

为了简化这个函数的定义，可以将问候消息的创建和返回写成一句:

func greetAgain(person: String) -> String {

              return "Hello again, " + person + "!"

}
print(greetAgain(person: "Anna"))

// 打印“Hello again, Anna!”

 

函数参数与返回值

函数参数与返回值在 Swift 中非常的灵活。你可以定义任何类型的函数，包括从只带一个未命名参数的简单函数到复杂的带有表

达性参数名和不同参数选项的复杂函数。

 

无参数函数

函数可以没有参数。下面这个函数就是一个无参数函数，当被调用时，它返回固定的 String 消息:

func sayHelloWorld() -> String {

             return "hello, world"

}

print(sayHelloWorld())

// 打印“hello, world”

尽管这个函数没有参数，但是定义中在函数名后还是需要一对圆括号。当被调用时，也需要在函数名后写一对圆括号。

 

多参数函数

函数可以有多种输入参数，这些参数被包含在函数的括号之中，以逗号分隔。

下面这个函数用一个人名和是否已经打过招呼作为输⼊，并返回对这个⼈的适当问候语:

func greet(person: String, alreadyGreeted: Bool) -> String {

         if alreadyGreeted {

                   return greetAgain(person: person)

         } else {

                   return greet(person: person)

         }

}

print(greet(person: "Tim", alreadyGreeted: true))

// 打印“Hello again, Tim!”

你可以通过在括号内使用逗号分隔来传递一个 String 参数值和一个标识为 alreadyGreeted 的 Bool 值，来调用

greet(person:alreadyGreeted:) 函数。注意这个函数和上面 greet(person:) 是不同的。虽然它们都有着同样的名字 greet ，但是 

greet(person:alreadyGreeted:) 函数需要两个参数，⽽ greet(person:) 只需要一个参数。

 

无返回值函数

函数可以没有返回值。下⾯是 greet(person:) 函数的另一个版本，这个函数直接打印一个 String 值，⽽不是返回它:

func greet(person: String) {

             print("Hello, \(person)!")

}

greet(person: "Dave")

// 打印“Hello, Dave!”

因为这个函数不需要返回值，所以这个函数的定义中没有返回箭头(->)和返回类型。

注意

严格地说，即使没有明确定义返回值，该 greet(Person:) 函数仍然返回一个值。没有明确定义返回类型的函数返回一个 Void 类

型特殊值，该值为一个空元组，写成 ()。

调⽤函数时，可以忽略该函数的返回值:

func printAndCount(string: String) -> Int {

          print(string)

          return string.count

}

func printWithoutCounting(string: String) {

          let _ = printAndCount(string: string)

}

printAndCount(string: "hello, world")

// 打印“hello, world”，并且返回值 12

printWithoutCounting(string: "hello, world")

// 打印“hello, world”，但是没有返回任何值

第一个函数 printAndCount(string:) ，输出一个字符串并返回 Int 类型的字符数。第二个函数 printWithoutCounting(string:) 调⽤

了第⼀个函数，但是忽略了它的返回值。当第二个函数被调用时，消息依然会由第一个函数输出，但是返回值不会被用到。

注意

返回值可以被忽略，但定义了有返回值的函数必须返回一个值，如果在函数定义底部没有返回任何值，将导致编译时错误。

 

多重返回值函数

你可以用元组(tuple)类型让多个值作为一个复合值从函数中返回。

下例中定义了一个名为 minMax(array:) 的函数，作用是在一个 Int 类型的数组中找出最小值与最大值。

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 ，以便查询函数的返回值时可以通过名字访问

它们。在 minMax(array:) 的函数体中，在开始的时候设置两个工作变量 currentMin 和 currentMax 的值为数组中的第一个数。然

后函数会遍历数组中剩余的值并检查该值是否比 currentMin 和 currentMax 更⼩或更大。最后数组中的最小值与最大值作为一个

包含两个 Int 值的元组返回。

因为元组的成员值已被命名，因此可以通过 .(点) 语法来检索找到的最小值与最大值:

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”

需要注意的是，元组的成员不需要在元组从函数中返回时命名，因为它们的名字已经在函数返回类型中指定了。

 

可选元组返回类型

如果函数返回的元组类型有可能整个元组都“没有值”，你可以使用可选的元组返回类型反映整个元组可以是 nil 的事实。

你可以通过在元组类型的右括号后放置一个问号来定义一个可选元组，例如 (Int, Int)? 或 (String, Int, Bool)?

注意

可选元组类型如 (Int, Int)? 与元组包含可选类型如 (Int?, Int?) 是不同的。可选的元组类型，整个元组是可选的，而不只是元组中

的每个元素值。

前面的 minMax(array:) 函数返回了一个包含两个 Int 值的元组。但是函数不会对传入的数组执⾏任何安全检查， 如果 array 参数

是一个空数组，如上定义的 minMax(array:) 在试图访问 array[0] 时会触发一个运⾏时错误。

为了安全地处理这个“空数组”问题，将 minMax(array:) 函数改写为使用可选元组返回类型，并且当数组为空时返回nil :

func minMax(array: [Int]) -> (min: Int, max: Int)? {

           if array.isEmpty { return nil }

           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:) 函数返回的是一个存在的元组值还是 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”

 

隐式返回的函数

如果一个函数的整个函数体是一个单行表达式，这个函数可以隐式地返回这个表达式。举个例子，以下的函数有着同样的作用:

func greeting(for person: String) -> String {

             "Hello, " + person + "!"

}

print(greeting(for: "Dave"))                           // 打印 "Hello, Dave!"

func anotherGreeting(for person: String) -> String {

            return "Hello, " + person + "!"

}

print(anotherGreeting(for: "Dave"))           // 打印 "Hello, Dave!"

greeting(for:) 函数的完整定义是打招呼内容的返回，这就意味着它能使用隐式返回这样更简短的形式。 anothergreeting(for:) 函

数返回同样的内容，却因为 return 关键字显得函数更长。任何一个可以被写成一 ⾏ return 语句的函数都可以忽略 return 。

正如你将会在 《简略的 Getter 声明》 ⾥看到的， 一个属性的 getter 也可以使用隐式返回的形式。

 

函数参数标签和参数名称

每个函数参数都有一个参数标签(argument label)以及一个参数名称(parameter name)。参数标签在调用函数的时候使用;调用

的时候需要将函数的参数标签写在对应的参数前面。参数名称在函数的实现中使用。默认情况下，函数参数使用参数名称来作为

它们的参数标签。

func someFunction(firstParameterName: Int, secondParameterName: Int) {

// 在函数体内，firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值

}

someFunction(firstParameterName: 1, secondParameterName: 2)

所有的参数都必须有一个独一⽆⼆的名字。虽然多个参数拥有同样的参数标签是可能的，但是一个唯一的函数标签能够使你的代

码更具可读性。

 

指定参数标签

你可以在参数名称前指定它的参数标签，中间以空格分隔:

func someFunction(argumentLabel parameterName: Int) {

               // 在函数体内，argumentLabel 代表参数标签   parameterName 代表参数名称

}

这个版本的 greet(person:) 函数，接收一个人的名字和他的家乡，并且返回一句问候:

func greet(person: String, from hometown: String) -> String {

                 return "Hello \(person)! Glad you could visit from \(hometown)."

}

print(greet(person: "Bill", from: "Cupertino"))

// 打印“Hello Bill! Glad you could visit from Cupertino.”

参数标签的使用能够让一个函数在调用时更有表达力，更类似自然语言，并且仍保持了函数内部的可读性以及清晰的意图。