1、函数的定义和调用

Java:求和
public int add(int a, int b){
    return a+b;
}
add(10,15)

function: 功能  作用  函数 
func 函数名（参数名1：参数类型， 参数名2：参数类型）->返回值类型{
    函数体
    return 返回值 
}
*/
func add(a:Int,b:Int)->Int{
    let sum = a + b 
    return sum;
}
print(add(a:20,b:40))
func test1()->Void{
    print("这是一个无参无返回值的函数")
}
test1()

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

func test3(){//最常用
    print("这是一个无参无返回值的函数")
}
test3()

//有参无返回值
func call(phoneNumber:String){
    print("给\(phoneNumber)电话")
}
call(phoneNumber:"10002")

//无参有返回值
func getMsg()->String{
    return "这是来自10086的方法"
}
print(getMsg())

//使用注意1，函数默认let类型   2、返回值有多个时可以使用元组数组
func say(info:String){
    print("传入的信息：\(info)")
}
say(info:"今天星期四")

//定义一个函数：找到数组里的最大值和最小值，然后返回

func getMaxAndMin(array:[Int])->(Int,Int){
    let min = array.min()
    let max = array.max()
    return (min!,max!)
}
var scores = [30,60,10,88]
let result = getMaxAndMin(array:scores)
print("最低分\(result.0),最高分\(result.1)")

内部和外部参数名
1、 外部名十大名：外面的调用，内部参数是小名：函数里面用

func minus1(a:Int,b:Int)->Int{
    return a - b 
}
//num1是外部参数名，a叫内部参数名
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:20,b:9)
minus2(num1:50,num2:20)
minus3(10,num2:5)

//默认参数

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:"?")//感叹号分割，问好结尾

//二、可变参数 —— 传入的参数个数不确定的时候

/*
需求1：求2个Int类型的和
需求2：求3个Int类型的和
想法：能不能设计一个函数，任意个数的和？
函数的参数个数是不确定的--可变参数
*/
//变量类型后面加 ... 定义可变参数  2、一个函数里只能有一个可变函数
func add(nums:Int...)->Int{
//问题：使用nums这个可变参数？
    print(type(of:nums))//判断类型Array 可变参数当作数组来处理
    var sum = 0 
    for i in nums{
        sum += i 
    }
    return sum
}
print(add(nums:10,20))
print(add(nums:50,40,10))

//三、输入输出参数
//为什么要输入输出函数？ 需求：定义一个swap函数，交换a\b的值。
func swap(a:inout Int,b:inout Int){
    let tmp = a 
        a = b 
        b = tmp
        print("a:\(a),b:\(b)")
}
var num1 = 10
var num2 = 30 
swap(a:&num1,b:&num2)

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

func add(a:Int,b:Int)->Int{
    return a + b 
}
func minus(a:Int,b:Int)->Int{
    return a - b 
}
/*
add函数的类型是：(Int,Int) ->Int，
可以解读为"这个函数有两个Int类型的值，并且返回一个Int型的值
*/
func printHelloWord(){
    print("hello,word")
}
/*
printHelloWord函数的类型是：()-> Vpid，
或者叫“没有参数，并返回Void类型的函数
*/

//函数使用场景一：函数类型的使用
var op = add //op是一个函数，什么类型？(Int,Int) ->Int
print(op(35,25))
op = minus
print(op(35,25))

//函数使用场景二：/函数作为参数
func printResult(a:Int,b:Int,mathFunc:(Int,Int)->Int){//函数作为参数
    print(mathFunc(a,b))
}
printResult(a:35,b:25,mathFunc:add)//调用add函数
printResult(a:35,b:25,mathFunc:minus)//调用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:9)(10,20))