swift 函数（函数定义、函数调用、函数类型、嵌套函数）

函数定义与调用

• 无参数，无返回值(没有定义返回类型的函数会返回Void，它其实是一个空的元组,可以写成())

func sayHI(){
    print("sayHI")
}
sayHI()

• 有参数，无返回值

func sayHI(name:String)  {
    print("hello " + name)
}
sayHI(name: "lily")

• 无参数，有返回值

func sayHI() -> String {
    return "sayHI"
}
let str = sayHI()

• 有参数，有返回值

func sayHI(name:String,age:Int) -> String {
    return "我是\(name),今年\(age)岁"
}
let str = sayHI(name: "lily", age: 12)

---

函数参数标签和参数名称

• 指定参数标签(参数名称前面编写参数标签，用空格分隔)

func sayHI(nameLabel name:String,ageLabel age:Int) -> String {
    return "我是\(name),今年\(age)岁"
}

• 省略参数标签(不想要参数的参数标签，请为该参数编写下划线（_）)

func sayHello(_ name:String,ageLabel age:Int) {
    print("我是\(name),今年\(age)岁")
}
sayHello("lily", ageLabel: 12)

• 默认参数值(函数体中可以为参数定义默认值，当默认值被定义之后，调用函数时可以忽略这个参数)
  将没有默认值的参数放在函数参数列表的最前

func sayHello(nameLabel name:String,ageLabel age:Int = 12) {
    print("我是\(name),今年\(age)岁")
}
sayHello(nameLabel: "lily")

• 可变参数
  • 一个可变参数可以接受零个或多个值
  • 函数调用时,函数参数可以传入多个
  • 在变量类型名后面加入（...）的方式来定义可变参数
  • 可变参数的传入值在函数体中以数组形式读取
  • 一个函数最多只能拥有一个可变参数

func message(_ str:String ...) {
    print(str[0] + " " + str[1])
}
message("hello","world")

• 指针类型(输入输出参数)
  • 输入输出参数可以改变函数体外的值
  • 定义输入输出参数时，在参数定义前加 inout关键字
  • 输入输出参数不能有默认值，而且可变参数不能用 inout 标记
  • 只能传递变量给输入输出参数,当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改

func exchangeValue(valueA value1:inout Int,valueB value2:inout Int) {
        let temp = value1
        value1 = value2
        value2 = temp   
}

var a = 3
var b = 5
exchangeValue(valueA: &a, valueB: &b)
print("\(a),\(b)")   //5,3

---

函数类型

• 函数的类型由函数的参数类型和返回类型组成

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

这个函数的类型是(Int, Int) -> Int,可以理解为“这个函数类型有俩个Int型的参数并返回一个Int型的值”

func sayHI(){
    print("sayHI")
}

这个函数的类型是() -> void,可以理解为“这个函数类型没有参数，返回Void类型的函数”

• 函数类型的使用
  定义一个类型为函数的常量或变量，并将适当的函数赋值给它

func add(_ a:Int, _ b:Int) -> Int {
    return a + b
}
//定义一个叫做 function 的变量，类型是‘一个有两个 Int 型的参数并返回一个 Int 型的值的函数’，并让这个新变量指向 add 函数
var function :(Int,Int)-> Int = add
print(function(2,3))

• 函数类型作为参数
  定义了 showResult(_:_:_:) 函数，它有三个参数：第一个参数叫fun，类型是 (Int, Int) -> Int，你可以传入任何这种类型的函数；第二个和第三个参数叫 a 和 b，它们的类型都是 Int，这两个值作为已给出的函数的输入值

func showResult(_ fun:(Int,Int)->Int,_ a:Int,_ b:Int) {
    print(fun(a,b))
}

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

showResult(add(_:_:), 3, 2)

showResult(_:_:_:) 函数的作用就是输出另一个适当类型的数学函数的调用结果。它不关心传入函数是如何实现的，只关心传入的函数是不是一个正确的类型。这使得 showResult(_:_:_:) 能以一种类型安全（type-safe）的方式将一部分功能转给调用者实现。

• 函数类型作为返回值
  定义了两个简单函数，分别是 sayHI(_:) 和 sayHello(_:),这两个函数的类型都是 (String) -> String。之后在定义一个showResult(:) 的函数，它的返回类型是(String) -> String 类型的函数。showResult(backward:) 根据布尔值来返回(String) -> String类型函数

func sayHI(_ name:String) -> String {
    return "HI \(name)"
}
func sayHello(_ name:String) -> String {
    return "Hello \(name)"
}
func showResult(_ backward: Bool) -> (String) -> String {
    return backward ? sayHI : sayHello
}

 let show = showResult(true)
 print(show("world"))    //HI world

---

嵌套函数

把函数定义在别的函数体中，称作嵌套函数

func showResult(_ backward: Bool) -> (String) -> String {
    func sayHI(_ name:String) -> String {
        return "HI \(name)"
    }
    func sayHello(_ name:String) -> String {
        return "Hello \(name)"
    }
    return backward ? sayHI : sayHello
}
 let show = showResult(true)
 print(show("world"))    //HI world