Swift--函数

使用函数

func 函数名（参数列表）->返回值类型 {
语句组
return 返回值
}

传递参数

未使用外部参数名

func rectangleArea(width: Double, height: Double) -> Double           {
    let area = width * height
    return area
}

print("320X480的长方形的面积：\(rectangleArea(width: 320, height: 480))")

使用外部参数名

func rectangleArea2(W width:Double, H height: Double) ->Double {
    let area = width * height
    return area
}
print("320X480的长方形的面积：\(rectangleArea2(W: 320, H: 480))")

省略外部参数名

func rectangleArea3(W width:Double, _ height: Double) ->Double {
    let area = width * height
    return area
}

print("320X480的长方形的面积：\(rectangleArea3(W: 320, 480))")

参数默认值

func makecoffee (type: String = "卡布奇诺") -> String {
    return "制作一杯\(type)咖啡。"
}

let cof1 = makecoffee(type: "拿铁")
let cof2 = makecoffee()//没有传type值，则为默认参数值“卡布奇诺”

print(cof1) //输出：制作一杯拿铁咖啡。
print(cof2)//输出：制作一杯卡布奇诺咖啡。

可变参数

参数类型名后面加入（...）的方式，来指示这是可变参数。

func sum(numbers: Double...) ->Double {
    var total: Double = 0
    for number in numbers {
        total += number
   }
    return total
}

//可传入不同数量的参数
print(sum(numbers: 100.0, 20, 30))//参数类型必须相同
print(sum(numbers: 30, 80))

参数的传递引用

如果我们一定要将一个值类型参数作为引用传递，Swift提供了inout关键字，可以实现这个目的。

//参数的传递引用
func increment(value: inout Double, amount: Double = 1.0) {
    value += amount
}

var value = 10.1

increment(value: &value)// &符号说明这是一种传入传出类型的参数

print(value) // 输出：11.1  成功改变了函数外部变量value的值

注： inout修饰的参数是不能有默认值的，有范围的参数集合也不能被修饰； 一个参数一旦被inout修饰，就不能再被var和let修饰了。

函数返回值

无返回值

func 函数名（参数列表){
语句组
}
func 函数名（参数列表)->(){
语句组
}
func 函数名（参数列表)->void{
语句组
}

多返回值函数

• 一种方法是：将函数的多个参数声明为引用类型传递。
• 另一种方法是：返回元组类型。

//多返回值
//(x:Int, y:Int) 是一个元组类型
func postion(dt: Double, speed:(x:Int, y:Int))->(x:Int, y:Int) {
    let posx: Int = speed.x * Int(dt)
    let posy: Int = speed.y * Int(dt)

    return (posx, posy)
}

函数类型

每个函数都有一个类型，使用函数的类型与使用其他数据类型一样，可以声明变量或常量，也可以作为其他函数的参数或者返回值使用。

func syHello(){
print("Hello, World")
}
函数类型是()->()

func rectangleArea4(width: Double, height: Double)-> Double {
...
}
函数类型是(Double, Double)->Double

注：函数类型作为一种数据类型，本质上与其他数据类型没有区别。作为数据类型可以出现在3种情况下：

1、声明变量或常量的类型。
2、指定函数中参数的类型。
3、指定函数返回值的类型。

作为函数返回类型使用

我们可以把函数类型作为另一个函数的返回类型使用。

//把函数类型作为另一个函数的返回类型使用

//定义计算长方形面积函数
//函数类型：(Double, Double)->Double
func rectangleArea4(width: Double, height: Double)-> Double {
    let area = width * height
    return area
}

//定义计算三角形面积函数
//函数类型：(Double, Double)->Double
func triangleArea(bottom: Double, height: Double) -> Double     {
    let area = 0.5 * bottom * height
    return area
 }

func getArea(type: String) -> (Double, Double) -> Double {
var returnDunction: (Double, Double) -> Double

    switch (type) {
    case "rect":
        returnDunction = rectangleArea4
    case "tria":
        returnDunction = triangleArea
    default:
        returnDunction = rectangleArea4
    }
    return returnDunction
}

//获得计算三角形面积函数
var area: (Double, Double) -> Double = getArea(type: "tria")
print("底10 高15， 三角形面积：\(area(10, 15))")

//获得计算长方形面积函数
area = getArea(type: "rect")
print("底10 高15， 长方形面积：\(area(10, 15))")

作为参数类型使用

我们可以把函数类型作为另一个函数的参数类型使用。

//把函数类型作为另一个函数的参数类型使用。
//定义计算长方形面积函数

//函数类型：(Double, Double)->Double
func rectangleArea4(width: Double, height: Double)-> Double {
    let area = width * height
    return area
}

//定义计算三角形面积函数
//函数类型：(Double, Double)->Double
func triangleArea(bottom: Double, height: Double) -> Double   {
    let area = 0.5 * bottom * height
    return area
}

func getAreaByFunc(funcName:(Double, Double) -> Double, a: Double, b: Double) -> Double {
    let area = funcName(a, b)
    return area
}

//获得计算三角形面积函数
var result: Double = getAreaByFunc(funcName: triangleArea, a: 10, b: 15)
print("底10 高15， 三角形面积：\(result)")

//获得计算长方形面积函数
result = getAreaByFunc(funcName: rectangleArea4, a: 10, b: 15)
print("宽10 高15，计算长方形面积：\(result)")

注：元组类型与函数类型的区别。

• （x:Int, y:Int）是一个元组，需要有字段名（x:）和类型
• （Double, Double)->Double是函数类型，只有类型，没有字段名，有返回值->Double。

函数嵌套

我们可以把函数定义在另外的函数体中，称作“嵌套函数”。

////函数嵌套
func calculate(opr: String)->(Int, Int) -> Int{
    //定义 + 函数
    func add(a: Int, b: Int) -> Int {
        return a + b
    }

    //定义 - 函数
    func sub(a:Int, b: Int) -> Int {
        return a - b
    }

    var result: (Int, Int) -> Int
    switch (opr) {
    case "+":
        result = add
    case "-":
        result = sub
    default:
        result = add
    }
    return result
}

let f1: (Int, Int) -> Int = calculate(opr: "+")
print("10 + 5 = \(f1(10, 5))")
let f2: (Int, Int) -> Int = calculate(opr: "-")
print("10 - 5 = \(f2(10, 5))")