函数的定义

当你定义一个函数时，你可以定义一个或多个有名字和类型的值，作为函数的输入，称为参数，也可以定义某种类型的值作为函数执行结束时的输出，称为返回类型。
每个函数有个函数名，用来描述函数执行的任务。要使用一个函数时，用函数名来“调用”这个函数，并传给它匹配的输入值（称作实参）。函数的实参必须与函数参数表里参数的顺序一致。

function：功能 作用 函数
func 函数名(参数名1：参数类型， 参数名2：参数类型…) -> 返回值类型 {
    函数体…
    return 返回值
}
调用： 函数名(参数名：实参1,参数名：实参2)

函数参数与返回值

函数参数与返回值在 Swift 中非常的灵活。你可以定义任何类型的函数，包括从只带一个未名参数的简单函数到复杂的带有表达性参数名和不同参数选项的复杂函数。

常见的几种函数类型:

有参有返回值的函数

func add(a:Int,b:Int)->Int{
    let sum = a + b
    return sum;
}
print(add(a:10,b:30))

无参无返回值

func test1()->Void{
   print("这是一个无参无返回值的函数")
}
test1()

func test2()->(){
   print("这是一个无参无返回值的函数")
}
test2()

func test3(){//最常用
   print("这是一个无参无返回值的函数")
}
test3()
//注意:返回值可以被忽略，但定义了有返回值的函数必须返回一个值，如果在函数定义底部没有返回任何值，将导致编译时错误。

有参无返回值

func call(phoneNumber:String){
    print("给\(phoneNumber)打电话")
}
call(phoneNumber:"10001")

无参有返回值

func HW() -> String {
    return "hello, world"
}
print(HW())
// 打印“hello, world”

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

使用注意

(1）函数的参数默认都是let类型
(2）返回值返回多个：可以用元组或者数组等

内部和外部参数名

总结：

外部参数名是大名，外面人喊(调用的时候用)；
内部参数名是小名，家里人喊(函数体中使用)

func minus1(a:Int,b:Int)->Int{
    return a - b
}

//num1是外部参数名，a叫内部参数名;num2是外部参数名，b叫内部参数名;a,b在函数体中使用，num1、num2在调用的时候使用
func minus2(num1 a:Int,num2 b:Int)->Int{
    return a - b
}

//_忽略外部参数名
func minus3(_ a:Int,num2 b:Int)->Int{
    return a - b
}

minus1(a:10,b:3)
minus2(num1:10,num2:3)
minus3(10,num2:3)

默认参数值

可以在函数体中通过给参数赋值来为任意一个参数定义默认值。当默认值被定义后，调用这个函数时可以忽略这个参数。

func order(item:String = "绿茶")->String{
    return "您点了\(item)"
}
//调用时可以再次赋值，或者不处理
print(order(item:"红茶"))
print(order())

//思考：我们之前学过了哪个函数，里面涉及了默认参数？-print
print(1,2,3,4)
print(1,2,3,4,separator:"!",terminator:"?")
//将不带默认值的参数放在最前保证在函数调用时，非默认参数的顺序是一致的，同时也使得相同的函数在不同情况下调用时显得更为清晰。

可变参数

使用场景：传入的参数个数不确定的时候
通过在变量类型名后面加入（...）的方式来定义可变参数。
一个函数最多只能拥有一个可变参数。

需求：求2个Int型数的和
需求：求3个Int型数的和
想法：能不能设计一个函数，求任意个数的和？也就是这个函数的参数个数是不确定的。---》可变参数

func add(nums:Int...)->Int{
    //问题：如何使用nums这个可变参数？
    print(type(of:nums))//可变参数当成数组来处理
    var sum = 0
    for i in nums{
        sum += i
    }
    return sum
}
print(add(nums:10,20))
print(add(nums:10,20,30))

输入输出参数

如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）。
（1）定义一个输入输出参数时，使用 inout 关键字
（2）只能传递变量给输入输出参数，传入常量或者字面量。需要在参数名前加 & 符，表示这个值可以被函数修改。

func swap2(a:inout Int,b:inout Int){
    let tmp = a
    a = b
    b = tmp
    print("a:\(a),b:\(b)")
}
var num1 = 10
var num2 = 30
swap2(a:&num1,b:&num2)
print("num1:\(num1),num2:\(num2)")
//注意
//输入输出参数和返回值是不一样的。

函数类型

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

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

func minus(a:Int,b:Int)->Int{
    return a-b
}

这两个函数的类型是： (Int, Int) -> Int，可以解读为:“这个函数有两个 Int 型的参数并返回一个 Int 型的值”。

func printHelloWorld() {
    print("hello, world")
}

printHelloWorld()函数的类型是： () -> Void，或者叫“没有参数，并返回 Void 类型的函数”

函数类型的使用

使用场景一：把一个函数给常量或变量

此时 Swift 可以自动推断其函数类型

var vip = add //Swift可以推断出vip是一个函数，函数类型是(Int, Int) -> Int
print(vip(10,50))
vip = minus
print(vip(10,30))//minus(10,30)

使用场景二：函数作为参数

func printResult(a:Int,b:Int,mathFunc:(Int,Int)->Int){
    print(mathFunc(a,b))
}
printResult(a:10,b:20,mathFunc:add)
printResult(a:10,b:20,mathFunc:minus)

使用场景三：函数作为返回值

func getFunction(a:Int)->(Int,Int)->Int{
    if a>10{
        return add
    }else{
        return minus
    }
}
print(getFunction(a:12)(10,20))
print(getFunction(a:4)(10,20))