函数的定义与调用, 函数的参数与返回值, 函数参数标签和参数名称, 函数类型, 嵌套函数

//函数是一段完成特定任务的独立代码段.
//在 Swift 中,每个函数都有一个由函数的参数值类型和返回值类型组成的类型.

//1.函数的定义与调用
//func 函数名(参数) -> 返回值类型 {}
func greet(person:String)->String {
    return "Hello \(person)!"
}
print(greet(person: "DJ"))

func greetAgain(person: String) -> String {
    return "Hello again, " + person + "!"
}

//2.函数参数与返回值
//2.1.无参数函数
func sayHelloWorld()->String {
    return "Hello world!"
}
sayHelloWorld()
//注:无参数函数在定义时,函数名后面依旧需要添加一对圆括号.在调用时,也需要在函数名后面天剑一对圆括号.

//2.2.多参数函数,多个参数间以逗号分隔
func greet2(person:String,alreadyGreeted:Bool)->String {
    if alreadyGreeted {
        return greetAgain(person: person)
    } else {
        return greet(person: person)
    }
}
print(greet2(person: "Tom", alreadyGreeted: true))

//2.3.无返回值函数
func greet3(person:String) { //该函数无返回值,故不需要在声明的后面添加返回箭头(->)和返回值类型
    print("Hello \(person)")
}
greet3(person: "Anna")
//注:严格意义上,即使函数被声明为无返回值,函数依旧返回了值.没有定义返回类型的函数会返回一个特殊的 void 值,它其实是一个空的元组,没有任何元素,可以写成 ().


//注:带返回值的函数必须在函数体结束时返回一个值,该值得类型应和声明函数时的返回值的类型一致. 函数的返回值并不一定被使用.


//2.4.多重返回值函数
//可以使用元组类型让多个值作为一个复合值从函数中返回
func minMax(array:[Int]) -> (min:Int,max:Int) {
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin,currentMax)
}
print(minMax(array: [0,2,5,3,9]).min)
print(minMax(array: [0,2,5,3,9]).max)
//注:元组的成员不需要在元组从函数中返回时命名,因为他们的名字已经在函数返回值类型中指定了.


//2.5.可选元组返回类型
//如果函数返回的元组类型有可能整个元组都没有值,你可以使用可选的元组返回类型反映整个元组可以是 nil 的事实.你可以通过在元组类型的右括号后放置一个问号来定义一个可选元组.
//注:可选元组类型如:(Int,Int)? 与元组包含可选类型如:(Int?,Int?)是不同的,可选的元组类型是整个元组都是可选的,而不只是元组中的每个元素值.
//2.4中的函数 minMax(array:)没有对传入的数组做任何安全检查,如果传入的参数是个空数组,那么就会造成运行时错误.所以可以进行下列处理:
func safeMinMax(array:[Int]) -> (min:Int,max:Int)? {
    if array.isEmpty {return nil}
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin,currentMax)
}
print(safeMinMax(array: [5,2,6,8,1])?.max as Any)


//3.函数参数标签和参数名称
//每个函数参数都有一个参数标签以及一个参数名称,参数标签在调用函数的时候使用,调用的时候需要将函数的参数标签写在对应的参数前面,参数名称在函数的实现中使用.默认情况下,函数参数使用参数名称来作为它们的参数标签.

//3.1.指定参数标签
func someFunction(agrumentLabel parameterName:Int) {
    //在函数体内,parameterName代表参数值
}
someFunction(agrumentLabel: 5)

func greet5(person:String,from hometwon:String)->String {
    return "Hello \(person)! Glad you could visit from \(hometwon)."
}
print(greet5(person: "Nacy", from: "ZK"))
//参数标签的使用能够让一个函数在调用时更具表达力,更加类似自然语言.

//3.2.忽略参数标签
//如果你不希望为某个参数添加一个标签,可以使用一个下划线(_)来代替一个明确的参数标签.
func someFunction2(_ firstParameterName:Int,secondParameterName:Int) {
    //在函数体内,firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值.
}
someFunction2(1, secondParameterName: 2)

//3.3.默认参数值
//你可以在函数体中通过给参数赋值来为任意一个参数定义默认值,当默认值被定义后,调用这个函数时可以忽略这个参数.
func someFunction3(parameterWithoutDefault:Int,parameterWithDefault:Int = 12) {
    //如果你在调用的时候不传递第二个参数,那么 parameterWithDefault 这个参数将会以值为 12 传入函数体中.
}
someFunction3(parameterWithoutDefault: 3, parameterWithDefault: 6) //parameterWithDefault = 6
someFunction3(parameterWithoutDefault: 3) //parameterWithDefault = 12
//注:一般会将不带默认值的参数放在函数声明的前面

//3.4.可变参数
//一个可变参数可以接受 零个 或 多个值.函数调用时,你可以用可变参数来指定函数参数可以被传入不确定数量的输入值.通过在变量类型名后面加入(...)的方式来定义可变参数.
//可变参数的传入值在函数体中变为此类型的一个数组.
func arithmeticMean(_ numbers:Double...)->Double {
    var total:Double = 0
    for number in numbers {
        total += number
    }
    return total/Double(numbers.count)
}
print(arithmeticMean(1,2,3,4,5))
//注:一个函数最多只能拥有一个可变参数.


//3.5.输入输出参数
//函数参数默认是常量.试图在函数体中更改参数值将会导致编译错误.如果想要一个函数可以修改参数的值,并且想要在这些修改在函数调用结束后仍然存在,那么就应该把这个参数定义为输入输出参数.

//定义一个输入输出参数时,在参数定义前添加 inout 关键字即可.一个输入输出参数有传入函数的值,这个值被函数修改,然后被传出函数,替换原来的值.

//注:你只能传递变量给输入输出参数,你不能传入常量或者字面量,因为这些量是不能被修改的,当传入的参数作为输入输出参数时,需要再参数名前添加 & 符号,表示这个值可以被函数修改.
//注:输入输出参数不能有默认值,而且可变参数不能用 inout 标记.
func swapTwoInts(_ a:inout Int,_ b:inout Int) {
    let tem = a
    a = b
    b = tem
}
var someInt = 3
var anotherInt = 107
swap(&someInt, &anotherInt)
print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
//注:输入输出函数和返回值是不一样的.


//4.函数类型
//每个函数都有种特定的函数类型,函数的类型由函数的参数类型和返回类型组成.
func addTwoInts(_ a:Int,_ b:Int) -> Int {
    //这个函数的类型为: (Int,Int)->Int
    return a + b
}

func printSomething() {
    //这个函数的类型为: ()->Void
}

//4.1.使用函数类型
//在 Swift, 可以将函数类型像使用其他类型一样.
var mathFunction:(Int,Int)->Int = addTwoInts(_:_:)
print("\(mathFunction(2,3))")

let anotherMathFunction = addTwoInts //此时 anotherMathFunction 被推断为 (Int, Int) -> Int 类型

//4.2.函数类型作为参数类型
//可以将函数类型作为另一个函数的参数类型使用
func printMathResult(_ mathFunction:(Int,Int)->Int,_ a:Int,_ b:Int) {
    print("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts(_:_:), 5, 8) //将函数作为参数传递

//4.3.函数类型作为返回类型
//在返回箭头后面写一个完整的函数类型,即可将该函数类型作为函数的返回类型
func stepForward(_ input:Int)->Int {
    return input + 1
}
func stepBackward(_ input:Int)->Int {
    return input - 1
}
func chooseStepFunction(backward:Bool)->(Int)->Int {
    return backward ? stepBackward : stepForward(_:)
}

var currentValue = 3
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0) //moveNearerToZero 此时指向的是 stepBackward 函数.

print("Counting to zero:")
// Counting to zero:
while currentValue != 0 {
    print("\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")


//5.嵌套函数
//将函数定义在一个函数中,这种形式成为嵌套函数
//默认情况下,嵌套函数是对外不可见的,但是可以被它们的外围函数调用,一个外围函数也可以返回它的某一个嵌套函数,使得这个函数可以在其他域中被使用.
func chooseStepFunction2(backward:Bool)->(Int)->Int {
    func setpForward(input:Int)->Int {return input+1}
    func stepBackward(input:Int)->Int {return input-1}
    
    return backward ? setpForward(input:) : setpForward(input:)
}
print("Count Again")
var currentValue2 = -4
let moveNearerToZero2 = chooseStepFunction(backward: currentValue2 > 0)
// moveNearerToZero now refers to the nested stepForward() function
while currentValue2 != 0 {
    print("\(currentValue2)... ")
    currentValue2 = moveNearerToZero2(currentValue2)
}
print("zero!")