Swift教程(六)--函数

本次的教程是基于Swift5.1版本

函数是一个独立的代码块，用来执行特定的任务。通过给函数一个名字来定义它的功能，并且在需要的时候，通过这个名字来“调用”函数执行它的任务。

Swift 统一的函数语法十分灵活，可以表达从简单的无形式参数的 C 风格函数到复杂的每一个形式参数都带有局部和外部形式参数名的 Objective-C 风格方法的任何内容。形式参数能提供一个默认的值来简化函数的调用，也可以被当作输入输出形式参数被传递，它在函数执行完成时修改传递来的变量。

定义和调用函数

函数使用一个 func的关键字前缀。你可以用一个返回箭头 -> (一个连字符后面跟一个向右的尖括号)来明确函数返回的类型，例如:

func saySomeThing(someWord:String)->String{
let sayWord = "hello， "+someWord
return sayWord
}

函数的调用：

let say = saySomeThing(someWord: "world")

print(say)
//输出:hello， world

函数的形式参数和返回值

• 无形式参数的函数

函数没有要求必须输入一个参数，这里有一个没有输入形式参数的函数，无论何时它被调用永远会返回相同的 String信息：

func hellWorld()->String{

return "hello world!"
}

print(hellWorld())
//输出 hello world!

函数的定义仍然需要在名字后边加一个圆括号，即使它不接受形式参数也得这样做。当函数被调用的时候也要在函数的名字后边加一个空的圆括号。

• 多形式参数的函数

函数可以输入多个形式参数，可以写在函数后边的圆括号内，用逗号分隔：

func sayHelloWorld(a:String,b:String)->String{

return a + ","+b
}

let val = sayHelloWorld(a: "hello", b: "world")

print(val)
//输出 hello,world

• 无返回值的函数

函数定义中没有要求必须有一个返回类型,正因为它不需要返回值，函数在定义的时候就没有包含返回箭头（ ->）或者返回类型:

func saySomeThing(a:String){
print(a)
}

saySomeThing(a: "hello world")
//输出 hello world

• 多返回值的函数

为了让函数返回多个值作为一个复合的返回值，你可以使用元组类型作为返回类型：

func intAndString(dic:[Int:String])->(Int,String){

let keys = [Int](dic.keys)
let vals = [String](dic.values)
return(keys.first!,vals.first!)
//这里假设keys和vals数组一定不为空，做一次强制解析！
}

print(intAndString(dic: [1:"dapeng"]))
//输出(1, "dapeng")

• 可选元组返回类型

如果元组在函数的返回类型中有可能“没有值”，你可以用一个可选元组返回类型来说明整个元组的可能是 nil 。书法是在可选元组类型的圆括号后边添加一个问号（ ?）例如 (Int, Int)? 或者 (String, Int, Bool)? 。

注意： 类似 (Int, Int)?的可选元组类型和包含可选类型的元组 (Int?, Int?)是不同的。对于可选元组类型，整个元组是可选的，而不仅仅是元组里边的单个值。

这样上面的例子就可以这么写：

func intAndString(dic:[Int:String])->(Int,String)?{
let keys = [Int](dic.keys)
let vals = [String](dic.values)
return(keys.first!,vals.first!)//这里假设keys和vals数组一定不为空z，做一次强制解析
}

if let val = intAndString(dic: [1:"dapeng"]) {
print(val)
}
//输出：(1, "dapeng")

• 隐式返回的函数

如果整个函数体是一个单一表达式，那么函数隐式返回这个表达式。像长一点的有多行代码的函数使用 return 关键字。你写的任何只有一行 return 的函数都可以省略那个 return 。

func greeting(for person: String) -> String {
"Hello, " + person + "!"
}
print(greeting(for: "Dave"))
// Prints "Hello, Dave!"
func anotherGreeting(for person: String) -> String {
return "Hello, " + person + "!"
}
print(anotherGreeting(for: "Dave"))
// Prints "Hello, Dave!"

函数实际参数标签和形式参数名

每一个函数的形式参数都包含实际参数标签和形式参数名。实际参数标签用在调用函数的时候；在调用函数的时候每一个实际参数前边都要写实际参数标签。形式参数名用在函数的实现当中。默认情况下，形式参数使用它们的形式参数名作为实际参数标签。

func myName(firstName:String,secondName:String){
}

myName(firstName: "lee", secondName: "dapeng")

左右的形式参数必须有唯一的名字。尽管有可能多个形式参数拥有相同的实际参数标签，唯一的实际参数标签有助于让你的代码更加易读。

• 指定实际参数标签

在提供形式参数名之前写实际参数标签，用空格分隔：

func myName(myName name:String){
}

myName(myName: "dapeng")

如果你为一个形式参数提供了实际参数标签，那么这个实际参数就必须在调用函数的时候使用标签

• 省略实际参数标签

如果对于函数的形式参数不想使用实际参数标签的话，可以利用下划线（ _ ）来为这个形式参数代替显式的实际参数标签。

func myName(_ firstName:String,secondName:String){
}

myName("lee", secondName: "dapeng")

• 默认形式参数值

你可以通过在形式参数类型后给形式参数赋一个值来给函数的任意形式参数定义一个默认值。如果定义了默认值，你就可以在调用函数时候省略这个形式参数。

func myName(name:String = "dapeng"){
print(name)
}

myName();
//输出 dapeng

• 可变形式参数

一个可变形式参数可以接受零或者多个特定类型的值。当调用函数的时候你可以利用可变形式参数来声明形式参数可以被传入值的数量是可变的。可以通过在形式参数的类型名称后边插入三个点符号（ …）来书写可变形式参数。

传入到可变参数中的值在函数的主体中被当作是对应类型的数组。举个例子，一个可变参数的名字是 numbers类型是 Int…在函数的主体中它会被当作名字是 numbers 类型是 [ Int ]的常量数组。

func sum(numbers:Int...)->Int{
var total:Int  = 0
for number in numbers {
total+=number
}
return total
}
print(sum(numbers: 1,2,3))
//输出 6

一个函数最多只能有一个可变形式参数。

• 输入输出形式参数

就像上面描述的，可变形式参数只能在函数的内部做改变。如果你想函数能够修改一个形式参数的值，而且你想这些改变在函数结束之后依然生效，那么就需要将形式参数定义为输入输出形式参数。

在形式参数定义开始的时候在前边添加一个 inout关键字可以定义一个输入输出形式参数。输入输出形式参数有一个能输入给函数的值，函数能对其进行修改，还能输出到函数外边替换原来的值。

你只能把变量作为输入输出形式参数的实际参数。你不能用常量或者字面量作为实际参数，因为常量和字面量不能修改。在将变量作为实际参数传递给输入输出形式参数的时候，直接在它前边添加一个和符号 ( &) 来明确可以被函数修改。

func coutA(a:inout Int){
var tem = a
tem = 1
a = tem
}

var test = 123
coutA(a: &test)
print(test)
//输出 1

函数类型

每一个函数都有一个特定的函数类型，它由形式参数类型，返回类型组成。

例如：

func coutA(a:Int,b:Int)->Int{
return a+b
}

这个函数每个传入两个 Int值，返回一个 Int值

这个函数的类型都是 (Int, Int) -> Int 。也读作： “有两个形式参数的函数类型，它们都是 Int类型，并且返回一个 Int类型的值。”

再如：

func sayHello(){
print("hello")
}

这个函数的类型是 () -> Void，或者 “一个没有形式参数的函数，返回 Void。”

• 使用函数类型

你可以像使用 Swift 中的其他类型一样使用函数类型。例如，你可以给一个常量或变量定义一个函数类型，并且为变量指定一个相应的函数。

var coutB:(Int,Int)->Int = coutA

//或者写成 let coutB = coutA，和上面是等效的

coutB(1,2)
//输出：3

• 函数类型作为形式参数类型

你可以利用使用一个函数的类型例如 (Int, Int) -> Int作为其他函数的形式参数类型。这允许你预留函数的部分实现从而让函数的调用者在调用函数的时候提供。

例如：

func printCounA(function:(Int,Int)->Int,a:Int,b:Int){
print(function(a,b))
}
printCounA(function: coutA, a: 1, b: 2)
//输出 3

• 函数类型作为返回类型

你可以利用函数的类型作为另一个函数的返回类型。写法是在函数的返回箭头（ ->）后立即写一个完整的函数类型。

例如：

func coutA(a:Int,b:Int)->Int{
return a+b
}

func choseA()->(Int,Int)->Int{
return coutA
}

内嵌函数

到目前为止，你在本章中遇到的所有函数都是全局函数，都是在全局的范围内进行定义的。你也可以在函数的内部定义另外一个函数。这就是内嵌函数。

内嵌函数在默认情况下在外部是被隐藏起来的，但却仍然可以通过包裹它们的函数来调用它们。包裹的函数也可以返回它内部的一个内嵌函数来在另外的范围里使用。

你可以重写上面的例子

func choseA()->(Int,Int)->Int{
func coutA(a:Int,b:Int)->Int{
return a+b
}
return coutA
}