swift 函数

// 函数：
// 函数类型： 函数的参数类型和返回值类型决定
/*
 无参数无返回值的函数参数类型： ()->void
 
 */
// 以下函数类型为：(Int,Int)->Int
func addTwoInts(_ a:Int ,_ b:Int)->Int{
    return a + b
}
//定义函数类型的变量
var myfunc:(Int,Int)->Int = addTwoInts
//调用
myfunc(1,2) // //return 3

//函数类型作为函数参数的使用
func useFunc1(_ ff:(Int,Int)->Int,_ x:inout Int){
    x = ff(1,3)
}
var res = 0
useFunc1(addTwoInts(_:_:), &res)



//函数类型作为返回值： 在返回-> 后面写上完整的函数类型
func setForward(_ input: Int)->Int{
    return input + 1
}

func setBackWard(_ input:Int)-> Int{
    return input - 1
}
// 返回函数类型
func chooseStep(backward:Bool)->(Int)->Int {
    return backward ? setForward : setBackWard
}
let setselect = chooseStep(backward: true)
setselect(123)



//嵌套函数：把函数定义在函数中，只能在定义的函数中使用，可以被定义他的函数所调用
func chooseStep2(backward:Bool)->(Int)->Int {
    func setForward(_ input: Int)->Int{
        return input + 1
    }

    func setBackWard(_ input:Int)-> Int{
        return input - 1
    }
    return backward ? setForward : setBackWard
}

let setselect2 = chooseStep(backward: false)
setselect2(123)





//无返回值函数
func greet(person:String){
    print(person)
}

//无参函数
func sayHelloValue()->String{
    return "hello"
}
sayHelloValue()

//多参数
func greet(person: String,alreadlyGreeted: Bool)->String{
    if alreadlyGreeted {
        return person
    }else{
        return "false"
    }
}

greet(person: "123dss", alreadlyGreeted: true)


// 多重返回值函数
func minMax(array:[Int])->(min:Int,max:Int){
    var currentMin = array[0]
    var currentMax = array[1]
    for value in array[1..<array.count] {
        if value < currentMin{
            currentMin = value
        }else if value > currentMax{
            currentMax = value
        }
    }
    return (currentMin,currentMax)
}
let bounds = minMax(array: [8,-6,12,90,1])


//可选元组返回类型： 表示可能整个元组都没有值的情况，即返回的是nil
// (min,mac)? 类型
func minMax2(array:[Int])->(min:Int,max: Int)?{
    if array.isEmpty {
        return nil
        
    }
    var currentMin = array[0]
    var currentMax = array[1]
    for value in array[1..<array.count] {
        if value < currentMin{
            currentMin = value
        }else if value > currentMax{
            currentMax = value
        }
    }
    return (currentMin,currentMax)
}


// 如果一个函数的函数体只有一个表达式，那么return是可以省略的


// 函数的参数标签和参数名称
// func 函数名（参数标签 参数名称： 参数类型），参数标签可以不写，也可使用下划线来忽略
// 参数可以有默认的参数值
/**
 参数标签和参数名称都存在的情况下：
    可以理解为参数标签是给用户看的参数名称，是一个展示外部的参数
        参数名称为函数体内部使用的参数
 */
func greet(person: String,form homeTown: String = " hebei")->String{
    return "\(person) come here from \(homeTown)"
}

greet(person: "lemon", form: "beijing")

// 可变参数：使用 ... 表示,添加在参数类型的后面
func arithmeticMean(_ numbers: Double...) -> Double{
    var total: Double = 0
    for item in numbers {
        total += item
    }
    return total
}
arithmeticMean(1,2,3,4,5,5,6)

//输入输出参数： 可以简单理解为指针的调用，使用inout修饰符，添加在参数类型的前面
func swapTwoInts(_ a: inout Int,_ b: inout Int){
    let temp = a
    a = b
    b = temp
}
var x = 23
var y = 34
// 调用时候需要使用 & 来取地址
swap(&x, &y)
print("\(x)=\(y)")