swift_015（Swift 的函数）

//***********swift学习之15--函数--***************************

/*

 Swift 定义函数使用关键字 func，由函数名、参数、返回值组成。参数和返回值甚至可以是元组、带返回值的函数等

 */

// 1.1 不带参数

func nullParame() -> String {

    return"不带参数的函数！"

}

var valueStr:String? =nullParame()

print(valueStr!)

// 1.2 有入参的函数

// 例如：求圆的面积

func areaOfCircle(radius:Float) ->Float {

    let pai:Float =3.14

    return2*pai*radius*radius

}

areaOfCircle(radius: 4)

// 例如：求矩形的面积

func areaOfRectangle(width:Float,height:Float) ->Float {

    return width*height

}

areaOfRectangle(width: 5.1, height:4)

// 1.3 元组作为函数返回值

// 例如：定义了一个名为minMax(_:)的函数，作用是在一个Int数组中找出最小值与最大值。

// minMax(_:)不会对传入的数组执行任何安全检查，如果array参数是一个空数组，如上定义的minMax(_:)在试图访问array[0]时会触发一个运行时错误。为了安全地处理这个"空数组"问题，将minMax(_:)函数改写为使用可选元组返回类型，并且当数组为空时返回nil

func minMax(array:[Int]) -> (min:Int,max:Int)? {

    

    if array.isEmpty {return nil }   //返回的元祖这是可能为nil,应为optional,加"?"

    

    var temMin:Int = array[0]

    var temMax:Int = array[0]

    

    for temVulein array[1..<array.count] {

        if temVule < temMin {

            

            temMin = temVule

            

        } elseif temVule > temMax {

            

            temMax = temVule

        }

    }

    

    return (temMin,temMax)

}

var testArray:[Int] = [2,9,-6,16,7,20,23,4]

var temTuble = minMax(array:testArray)

print("\(testArray)中最小值为：\(temTuble!.0)最大值为：\(temTuble!.1)")

let responseStatus = (status:200,result:["message":"请求成功","data":["usr":"李振振","memberId":"2046"]])

print("元组的练习：status:\(responseStatus.status) result:\(responseStatus.1)")

// 如果你不确定返回的元组一定不为nil，那么你可以返回一个可选的元组类型。

// 你可以通过在元组类型的右括号后放置一个问号来定义一个可选元组，例如(Int, Int)?或(String, Int, Bool)?

// 注意

// 可选元组类型如(Int, Int)?与元组包含可选类型如(Int?, Int?)是不同的.可选的元组类型，整个元组是可选的，而不只是元组中的每个元素值。

// 1.4 外部参数名

// 你可以在局部参数名前指定外部参数名，中间以空格分隔，外部参数名用于在函数调用时传递给函数的参数。

// 如下定义以下两个函数参数名并调用它：

func pow(OutParame1 a:Int,outParame2 b:Int) ->Int {

    var res = a

    for _ in1..<b {

        

        // 为啥用“_”,因为没有使用的所以用“_”,代替。排除⚠️

        res = res*a

    }

    print(res)

    return res

}

pow(OutParame1: 5, outParame2:3)

// 注意:如果你提供了外部参数名，那么函数在被调用时，必须使用外部参数名。

// 1.5 可变参数

// 可变参数可以接受零个或多个值。可变参数形式：变量类型名后面加入（...）

//func testVaryParames(members: AnyObject...) {

//    for i in members {

//        print(i)

//    }

//}

func testVaryParames<N>(members:N...) {

    for iin members {

        print(i)

    }

}

testVaryParames(members: 4,3,5)

testVaryParames(members: 4.5, 3.1,5.6)

testVaryParames(members:"Google", "Baidu","Runoob")

// 1.6 常量，变量及 I/O参数

// 一般默认在函数中定义的参数都是常量参数，也就是这个参数你只可以查询使用，不能改变它的值。如果想要声明一个变量参数，可以在前面加上var，这样就可以改变这个参数的值了。

// 例如：

func swapTwoInts( a:Int, b:Int){

    

    var a = a

    var b = b

    let t = a

    a = b

    b = t

}

var x = 0,y =100

print("x =\(x) ;y =\(y)")

swapTwoInts(a: x, b:y)

print("x =\(x) ;y =\(y)")

// 变量参数，正如上面所述，仅仅能在函数体内被更改。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）。

func swapTwoIntsInout( a:inoutInt, b:inoutInt) {

    

    let t = a

    a = b

    b = t

}

var m = 0,n =100

print("m =\(m) ;n =\(n)")

swapTwoIntsInout(a: &m, b:&n)

print("m =\(m) ;n =\(n)")

// 1.7 函数类型

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

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

func sum(m:Int, n:Int) ->Int {

    return m+n

}

var addtiona:(_ a:Int,_ b:Int) ->Int = sum // 获取sum的函数类型

print("输出结果:   \(addtiona(10,14))")

// 1.8 由上节知道函数可以赋值一个类型为该函数的常量或变量（addtiona）。实际上就是变量的功能。作为函数的参数或返回值的作用。

// 也就是函数类型作为参数类型、函数类型作为返回类型

// 接着 1.7的例子

func another(testSum: (Int,Int) -> Int, a:Int, b: Int) {

    print("输出结果:\(testSum(a, b))")

}

another(testSum: sum, a:10, b: 20)

// 1.9 函数嵌套

// 指的是函数内定义一个新的函数，外部的函数可以调用函数内定义的函数。

func calcDecrement(forDecrement total:Int) -> Int {

   

    var overallDecrement =0

    func decrementer() ->Int {

        overallDecrement -= total

        return overallDecrement

    }

    

    let hhh:(()->Int) = decrementer

    // decrementer 函数类型 decrementer()为函数调用

    return hhh()

}

let decrem = calcDecrement(forDecrement:30)

print(decrem)