swift 函数特性

//函数体内享有外部所有作用域
let global = "global"
func fn (args: String, args2: String) -> String {
    print(global)
    return args + "	" + args2
}

var return_string: String =  fn("string1", args2: "string3331");
print(return_string)





//元组返回
func minMax(array: [Int]) -> (Int,Int)? {
    if array.isEmpty {
        return nil
    }
    var curren_min = array[0]
    var curren_max = curren_min
    //array[1..<2] 数组截取
    for value in array[1..<array.count] {
        if curren_min > value {
            curren_min = value
        }else if curren_max < value {
            curren_max = value
        }
    }
    return (curren_min, curren_max)
}

print(minMax([1,2,3,5,2,99,0]))





//外部参数名

func fnOutParams(in1 args1: String, in2 args2: String) {
    print(args1 + "  " + args2)
}
fnOutParams(in1: "aa", in2: "bb")




//省略外部参数名

func fnOutParams(args1: String, _ args2: String) {
    print(args1 + "  " + args2)
}
fnOutParams("aa", "bb")




//可变参数

func avgNumbers(numbers: Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total/Double(numbers.count)
}
print(avgNumbers(1,2,3,4,5.9,6,9,22))




//参数重赋值(默认let 常量参数)

func reFn(var args: String) {
    args = "cs";
    print(args)
}
reFn("reFn");




//inout 指针传值

func swapVariable(inout args: String, inout _ args2: String) {
    let tmp: String  = args
    args = args2
    args2 = tmp
}
var a = "args1"
var b = "args2"
swapVariable(&a, &b)
print(a + "	" + b)





// 函数类型

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

let addTwoInts2 = addTwoInts;
print(addTwoInts2(1, 2));


let variable_fn: (Int, Int) -> Int  = multiplyTwoInts;

print(variable_fn(1, 2));






//函数作为参数

func fnArgments(args: (Int, Int)-> Int, _ args2: Int, _ args3: Int) -> Int{
    return args(args2, args3)
}

print(fnArgments(addTwoInts2, 2, 3))





//函数作为返回值


func fnRetruns(args: (Int, Int) -> Int) -> (Int, Int) -> Int{
    return args
}

let return_value = fnRetruns(multiplyTwoInts)(1, 5)
print(return_value);




//嵌套函数

func fnNesting(bool: Bool) -> (Int) -> Int{

    func stepForward(input: Int) -> Int {
        return input + 1
    }

    func stepBackward(input: Int) -> Int {
        return input - 1
    }
 
    return bool ? stepForward : stepBackward
}

print(fnNesting(true)(2))