1、简单函数

func add(a:Int ,b:Int) -> Int{
    return a+b
}
//add 是一个函数名，剩下（）里是参数和对应的参数所属的类型，->是返回参数类型
print("1+2=\(add(a:1,b:2))")    //输出 1+2=3

2、无参函数

func sayHello() -> String{
    return "hello"
}
print(sayHello())

3、无返回值函数

func welcom() {
    print("welcom")
}
welcom()
func welocm2() -> (){
    print("welcome2")
}
welocm2()
func welcome3() -> Void{
    print("welcome3")
}
welcome3()

4、多个返回值函数

func studentInfo(id: String) -> (name: String, age: Int, sex: String){
    var name = "lili"
    var age = 13
    var sex = "man"
    if id == "lili" {
        name = "lele"
        age = 23
        sex = "woman"
    }
    return (name, age, sex)
}

print(studentInfo(id: "lili"))
let people = studentInfo(id: "lili")
print(people.name)

5、外部参数函数

以上的a、b、id都是在函数内部使用的，这些叫做局部参数名
//如果我们在这些参数名前面再加一个参数名，那前面加的这个参数名就要给外部参数，用的时候必须显示出来
例如

func add2(num1 a: Int, num2 b: Int) -> Int{
    return a + b
}
print(add2(num1: 1, num2: 2))

6、含有默认参数的函数

func sayWord(message: String, name: String = "lili") {
    print(message, name)
}
sayWord(message: "hello")
sayWord(message: "hi", name: "gg")

7、可变参数的函数

一个可变参数可以接受0个或者多个指定类型的值，函数调用时，使用可变参数来指定函数可以被传入

func addSum(nums: Double...) -> Double{
    var sum: Double = 0
    for i in nums {
        sum += i
    }
    return sum
}
print(addSum(nums: 1,2,4,5,6,78,9))

8、In - Out（输入输出）函数

一般参数仅仅是在函数内可以改变的，当一个函数执行完后变量就会被销毁，如果想通过一个函数可以修改参数值，并且让这个参数调用结束后依然存在

func testInout(a: inout Int, b: inout Int){
    a = 1
    b = 2
}
func testInout2(a: inout Int, b: inout Int){
    a += 1
    b += 2
}
var numA = 100
var numB = 30
testInout(a: &numA, b: &numB)
print("numA = \(numA), numB = \(numB)")
testInout2(a: &numA, b: &numB)
print("numA = \(numA), numB = \(numB)")
testInout2(a: &numA, b: &numB)
print("numA = \(numA), numB = \(numB)")

9、嵌套函数

前面定义的函数都是一个全局函数，定义在全局的作用域中，那我们还有一种函数是定义在另一个函数里面，对外是不可见的，但是可以被外围函数调用的

获取数组中最大的值

func getMaxFromArray(arr: Array<Int>) -> Int{
    func compareMax(a: Int, b: Int) -> Int{
        if a > b {
            return a
        }
        return b
    }
    
    var max = 0
    for i in arr {
        max = compareMax(a: max, b: i)
    }
    return max
}

var arr: Array<Int> = [3,7,2,8,4,2,7,3,6,8,4,3,6,3,23]
print(getMaxFromArray(arr: arr))

计算器

func calculator(str: 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 str {
    case "+":
        result = add
    default:
        result = sub
    }
    return result
}

other

func maxMin() -> (Int,Int){
    return (Int.min,Int.max)
}

maxMin().0
maxMin().1

func add2(x:Int,increment:Int = 2) -> Int{
    return x+increment
}

add2(x:2)

func calculate(x:Int , y: Int ,method : (Int,Int) -> Int) -> Int{
    return method(x,y)
}

func xxx(x: Int,y: Int) -> Int{
    return x*y
}

calculate(x: 3,y: 4,method: add)
calculate(x: 3,y: 4,method: xxx)