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

//“在 Swift 中，每个函数都有一个由函数的参数值类型和返回值类型组成的类型。 你可以把函数类型当做任何其他普通变量类型一样处理，这样就可以更简单地把函数当做别的函数的参数，也可以从其他函数中返回函数。函数的定义可以写在其他函数定义中，这样可以在嵌套函数范围内实现功能封装。 ***和OC不同的地方。

//1.函数的定义和调用
// “每个函数有个函数名，用来描述函数执行的任务。要使用一个函数时，用函数名来“调用”这个函数，并传给它匹配的输入值（称作 实参 ）。函数的实参必须与函数参数表里参数的顺序一致。”

func greet(person: String)->String{
    let greeting = "Hello," + person + "!"
    return greeting
}
print(greet(person: "andi"))

//2. 函数的参数和调用

//2.1无参数函数
func sayHelloWorld()-> String{
return "Hello ,World"
}
print(sayHelloWorld())

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

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

func greet(person:String,alreadyGreeded:Bool)->String{
    if alreadyGreeded {
        return  "hello " + person + " greet again!"
    }else{
     return greet(person: person)
    }
}
print(greet(person: "jack", alreadyGreeded: true))

//2.3无返回值函数
func greetNoReturn(person: String){
print("Hello,\(person)")
}
greetNoReturn(person: "lucy")

//注意：“严格上来说，虽然没有返回值被定义，greet(person:) 函数依然返回了值。没有定义返回类型的函数会返回一个特殊的Void值。它其实是一个空的元组（tuple），没有任何元素，可以写成()”
//注意：“返回值可以被忽略，但定义了有返回值的函数必须返回一个值”

//2.4 多重返回值函数
//“你可以用元组（tuple）类型让多个值作为一个复合值从函数中返回。

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)
}
let bounds = minMax(array: [1,58,-5,39,117,60])
print("min is \(bounds.min) max is \(bounds.max)")

//2.5 可选元组返回类型
//“如果函数返回的元组类型有可能整个元组都“没有值”，你可以使用可选的（ optional ） 元组返回类型反映整个元组可以是nil的事实。你可以通过在元组类型的右括号后放置一个问号来定义一个可选元组，例如 (Int, Int)? 或 (String, Int, Bool)?”

func optionalMinMax(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)
}
if let bounds = optionalMinMax(array: [8,36,777,13,-9,68]) {
    print("min is \(bounds.min) and max is \(bounds.max)")
}
//使用可选绑定来处理

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

func someFunction(firstParameterName:Int,secondParameterName:Int){
    //在函数体内，firstParameterName 和secondParameterName 代表参数中的第一个和第二个参数值
}
someFunction(firstParameterName: 1, secondParameterName: 2)

//3.1指定参数标签
//“你可以在函数名称前指定它的参数标签，中间以空格分隔”

func someFunctionAgain(argumentLabel parameterName:Int){
     //在函数中，parameterName代表参数值
    print("\(parameterName)")
}
someFunctionAgain(argumentLabel: 1)

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

//3.2忽略参数标签
//“如果你不希望为某个参数添加一个标签，可以使用一个下划线(_)来代替一个明确的参数标签。”

func ignoreFunction(_ firstParameter: Int ,secondName:Int){
print("\(firstParameter)")
    //函数内部，firstParameter代表第一个参数
}
ignoreFunction(1, secondName: 2)

//3.3 默认参数值
//“你可以在函数体中通过给参数赋值来为任意一个参数定义默认值（Deafult Value）。当默认值被定义后，调用这个函数时可以忽略这个参数。”

func defaultFunction(parameterWithoutDefault:Int,parameterWithDefault:Int = 12){

//如果在调用的时候不传第二个参数，parameterWithDetault 会值为12传到函数体中。

    print("defaultParameter:\(parameterWithDefault)")
}
defaultFunction(parameterWithoutDefault: 1)
defaultFunction(parameterWithoutDefault: 1, parameterWithDefault: 6)
//一般将不带有默认值的参数放在函数参数列表的最前

//3.4 可变参数
//“一个可变参数（variadic parameter）可以接受零个或多个值。函数调用时，你可以用可变参数来指定函数参数可以被传入不确定数量的输入值。通过在变量类型名后面加入（...）的方式来定义可变参数。”
//“可变参数的传入值在函数体中变为此类型的一个数组。例如，一个叫做 numbers 的 Double... 型可变参数，在函数体内可以当做一个叫 numbers 的 [Double] 型的数组常量。”

func arithmeticMean(_ numbers:Double...)->Double{
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}
arithmeticMean(3,5,8,10)

//3.5输入输出参数
// 函数参数默认是常量。 试图在函数体中更改参数值将会导致编译错误(compile-time error)。这意味着你不能错误地更改参数值。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）。”
//“定义一个输入输出参数时，在参数定义前加 inout 关键字。一个输入输出参数有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值”
//“你只能传递变量给输入输出参数。你不能传入常量或者字面量，因为这些量是不能被修改的。当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改。”

func swapTwoIns(_ a : inout Int, _ b : inout Int){
    let temporaryA = a
    a = b
    b = temporaryA
}

var someInt = 5
var anotherInt = 10
swap(&someInt, &anotherInt)
print("someInt:\(someInt),anotherInt:\(anotherInt)")  // someInt:10,anotherInt:5

//“我们可以看到 someInt 和 anotherInt 的原始值在 swapTwoInts(::) 函数中被修改，尽管它们的定义在函数体外。
//“注意：输入输出参数和返回值是不一样的。上面的 swapTwoInts 函数并没有定义任何返回值，但仍然修改了 someInt 和 anotherInt 的值。输入输出参数是函数对函数体外产生影响的另一种方式。

//4. 函数类型
//“每个函数都有种特定的函数类型，函数的类型由函数的参数类型和返回类型组成”

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

func multiplyTwoInts(_ a:Int ,_ b: Int)-> Int{
return a * b
}
//“这两个函数的类型是 (Int, Int) -> Int，可以解读为“这个函数类型有两个 Int 型的参数并返回一个 Int 型的值。”

func printhelloWorld(){
print("Hello,World")
}
// 这个函数的类型是 （）->Void类型

//4.1使用函数类型
//“在 Swift 中，使用函数类型就像使用其他类型一样。例如，你可以定义一个类型为函数的常量或变量，并将适当的函数赋值给它”

var mathFunction: (Int,Int)->Int = addTwoInts
print(mathFunction(2,3))
mathFunction = multiplyTwoInts(_:_:)
print(mathFunction(2,5))

//“定义一个叫做 mathFunction 的变量，类型是‘一个有两个 Int 型的参数并返回一个 Int 型的值的函数’，并让这个新变量指向 addTwoInts 函数”。”

//“像其他类型一样，当赋值一个函数给常量或变量时，你可以让 Swift 来推断其函数类型”

let anotherMathFounction = addTwoInts

//4.2 函数类型作为参数类型
//“你可以用 (Int, Int) -> Int 这样的函数类型作为另一个函数的参数类型。这样你可以将函数的一部分实现留给函数的调用者来提供。

func printMathResult(_ mathFunction:(Int,Int)->Int,_ a: Int,_ b: Int){
print("Result: \(mathFunction(a,b))")
}
printMathResult(addTwoInts(_:_:), 3, 5)
printMathResult(multiplyTwoInts(_:_:), 3, 5)

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

//4.3 函数作为返回值类型
//“你可以用函数类型作为另一个函数的返回类型。你需要做的是在返回箭头（->）后写一个完整的函数类型”

func stepForward(_ inpuit:Int)->Int{
return inpuit + 1
}
func stepBackward(_ inpuit:Int)->Int{
    return inpuit - 1
}
func chooseStepFunction(backward:Bool)->(Int)->Int{
    return backward ? stepBackward  : stepForward
}

var currentValue = 3
let moreNearToZero = chooseStepFunction(backward: currentValue>0)
//moreNearToZero现在指向stepBackward()函数
while currentValue != 0 {
    print("currentValue:\(currentValue)")
    currentValue = moreNearToZero(currentValue)
}
print("zero!")

//5。嵌套函数
//“到目前为止本章中你所见到的所有函数都叫全局函数（global functions），它们定义在全局域中。你也可以把函数定义在别的函数体中，称作 嵌套函数（nested functions）
//“默认情况下，嵌套函数是对外界不可见的，但是可以被它们的外围函数（enclosing function）调用。一个外围函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用。”

func againChooseStepFunctin(backward:Bool)->(Int)->Int{
    
    func againStepForward(_ input:Int)-> Int {
    return  input + 1
    }
    
    func againStepBackward(_ input:Int)-> Int {
    return input - 1
    }
  
   return backward   ?  againStepBackward : againStepForward
}

var  againCurrentValue = -4
let againMoveNearToZero = againChooseStepFunctin(backward: againCurrentValue>0)
while  againCurrentValue != 0 {
    print("againCurrentValue: \(againCurrentValue)")
     againCurrentValue = againMoveNearToZero(againCurrentValue)
}
print("again zero!")