Swift函数

1.函数的定义

func functionName(params:type)->returnValue{

}

这就是一个函数的基本构成
包裹func关键字表明是一个函数 functionName 函数名 (函数的参数) -> 返回值类型 {

}

2.返回多个返回值
这里其实本质还是返回一个返回值,但是swift中有元组这个东西,我们就可以利用元组的特性，往里面放置多个不同类型的值，然后返回这个元组，本质我们还是返回了一个元组，这是元组中有多个值而已
如:需要获得两个数的和 与积

func addMul(a:Int ,b:Int)->(c:Int, d:Int){
    return (a + b ,a * b)
}
let addValue = addMul(20, b: 10)

然后option看一下addValue的值 是一个元组 里面存有两个值

3.函数的参数使用
函数的参数是一个很好玩的地方
首先我们从个数来看
一个时:

func printYourInfo(name:String){
    print("\(name) ")
} 
printYourInfo("1Ran")

两个时

func printYourInfo(name:String ,age:Int){
    print("\(name) ,\(age)")
}
printYourInfo("1Ran", age: 18)

有没有发现 第二个参数有一个age: 为什么第一个没有呢 这里是为了参数提示 第一个没有是因为开发者认为应该名字中有提示 函数应该写为

func printYourInfoWithName(name:String ,age:Int){
    print("\(name) ,\(age)")
}

这样才是最完整的

外部参数:
为什么第二个参数提示的是age呢 因为我们声明这个函数的时候就是age 那加入我需要的是两年前的年龄要怎么写呢 可以这样写

func printYourInfo(name:String ,twoYearsAgoAge age:Int){
    //注意喽，函数内还是使用age  因为age name被称为内部参数  专门在函数内使用
    print("\(name) ,\(age)")
}

这样你在使用这个函数的时候代码就会自动提示twoYearsAgoAge了

隐藏外部参数：
加入我们写一个add函数 明确就是传两个数 我们就没必要提示 num1 num2 这时我们就可以隐藏外部参数 使用 "_"

func add(num1:Int ,_ num2:Int)->Int{
      return num1 + num2
}

这样写完后第二个参数就不会有提示了

可变参数：
当我们使用print()的时候有没有发现我们可以填任意多个数值，就是因为print()使用了可变参数 "..." 的使用 比如我们要计算多个数的和

func addNums(var num1:Int ,_ num2:Int...)->Int{
    for num in num2 {
        num1 += num
    }
    return num1
}
let num = addNums(1,2,3,4,5)   //num = 15哦

初始化参数
这也是一个很有意思的地方，你可以个参数一个初值，这样你在使用的时候可以考虑不给这个参数赋值 加入计算两个数的乘积

func mulNum(num1 :Int ,num2: Int = 10)->Int{
    return num1 * num2
}
    //使用的时候你会发现一件有意思的事   就是你有多个选择   
    //一个是没有第二个参数的   这时会默认使用默认值
    //另外一种就是两个参数  这样就不会使用默认值
mulNum(10, num2: 20)   //这里返回  200
mulNum(30)                    //这里返回  300

这里是重点哦！！！！还是关于参数
当你在函数内需要改变你的参数的时候，你会发现编译器会报错，option点一个那个参数看一下会发现，是一个let类型 我们需要明确标注他是一个var才可以

func ToBinary(var num:Int)->String{
    var str:String = ""
    repeat{
        str = "\(num % 2)" + str
        num /= 2;
    }while(num > 0)
    return str
}

这里num就设置成了var类型

let num = 10
ToBinary(num)
num      

思考一下 最后一个num的值回事多少呢 是10还是0呢
这里的答案就是10 为什么 因为num在赋值的时候是值传递 也就是num copy了一份 然后把copy的传递了进去 于是当我们执行完成后再看num时还是10
假如我们想修改num的值怎么办呢 这就引出了 inout关键字

//改写
func ToBinary1(inout num:Int)->String{
    var str:String = ""
    repeat{
        str = "\(num % 2)" + str
        num /= 2;
    }while(num > 0)
    return str
}
//在传参的时候也需要注意   这里需要
var num = 10   //这里需要是var哦
ToBinary(&num)
num    //这里你会发现   num为0

函数类型的使用
上面叫函数类型，每个函数有自己的类型，如：

func addNum(num1:Int ,num2:Int)->Int{
    return num1 + num2
}

这个函数是上面类型呢，很简单去掉func 去掉名字 是一种类型 自然不会关注函数名 去掉后面的{} 剩下的就是这个类型了 ，使用一下看看

let funcAdd:(Int,Int)->Int  = addNum
funcAdd(10 ,20)   //这里是30哦

我们可以将函数看做成一个变量 说到变量函数的参数也是变量 返回值也是变量 也就是说 函数类型 可以作为函数的参数 函数的返回值

先来讨论下作为参数的时候：
加入我们根据一个商品的重量来算价格 大于60时 为三倍价格 否则为一倍价格:

func price(weight:Double)->Double{
    if weight > 60 {
        return 3
    }else{
        return 1
    }
}
func totalPrice(weight:Double, goodPrice:(Double)->Double)- >Double{
    return weight * goodPrice(weight)
}
let goodP = totalPrice(70, goodPrice: price)

这里我们定义了第一个函数 然后在第二个函数中的第二个参数为第一个函数的函数类型 在使用的时候 第二个参数传入第一个函数的名称 就将第一个函数传入了

作为返回值使用的时候：
上面的情景改写 当物品重量大于60时 我们希望计算方式为 3 * weight + 10 小于60时 计算方式为 2 * 60 - 10 实现以下看看

func goodBigger60(weight:Double)->Double{
    return weight * 3 + 10
}
func goodSmaller60(weight:Double)->Double{
    return 60 * 2 - 10
}
func choseSumWith(weight:Double)->(Double)->Double{
    if weight >= 60 {
        return goodBigger60
    }else{
        return goodSmaller60
    }
}
let big60 = choseSumWith(70)
big60(70)
let small60 = choseSumWith(50)
small60(50)

使用的方法很简单 但是原理一样
最后说一下
函数是引用类型！！
函数是引用类型！！
函数是引用类型！！