2_2、函数

2018-06-03 | 阅读：

函数的定义

1、函数的定义

//形参默认是let 也只能是let
func sum(num1: Int,num2: Int) -> Int{
    return num1 + num2
    //num1 + num2 //隐式返回
}
//调用时 num1 与 num2 必须得写
print(sum(num1:10,num2:20))

2、无返回值

func sayHello(){
    print("hello")
}
sayHello()

3、返回元组实现多返回值

func calculate(v1:Int,v2:Int)->(sum:Int,dif:Int,aver:Int){
    let sum = v1 + v2
    return (sum,v1-v2,sum>>1)
}
let result = calculate(v1:8,v2:4)
print(result.sum,result.dif,result.aver)

函数的参数

1、参数标签

//定义一个函数
func goToWork(time:String){
    print("this time is \(time)");
}
goToWork(time:"08:00")


//可以修改参数标签
func goToWork1(at time:String){
    print("this time is \(time)");
}
//调用时修改参数标签为at
goToWork1(at:"09:00")


//省略参数标签
func goToWork2(_ time:String){
    print("this time is \(time)");
}
//调用时省略参数标签
goToWork2("10:00")

2、参数的默认值

func check(name:String="nobody",age:Int,job:String="none"){
    print("name=\(name),age=\(age),jon=\(job)")
}
check(name:"xiaoming",age:18)

3、可变参数

func sum24(numbers:Int...)->Int{
    var total = 0
    for number in numbers {
        total+=number
    }
    return total
}
print(sum24(numbers: 10,20,30,40))

//一个函数最多只能有1个可变参数
//紧跟在可变参数后面的参数不能省略参数标签
func test(_ numbers:Int...,string:String,_ other:String){
    print("test")
}
test(10,20,30,40, string: "bob", "other")

print函数的使用

func printUse(){
    print("1",12,"3")
    
    //separator的默认值是 " "
    print("1",12,"3",separator:"-")
    
    //terminator的默认值是 "\n"
    print("1",12,"3",terminator:"\n**\n")
    
    print("1",12,"3",separator: "-",terminator:"**\n")
}

输出结果

1 12 3
1-12-3
1 12 3
**
1-12-3**

输入输出参数

1、inout 使用

//可变参数不能标记为 inout
//inout参数不能有默认值
//inout 的本质是地址传递
func swapValues(num1:inout Int,num2:inout Int){
    let num3 = num1
    num1 = num2
    num2 = num3
    print("num1 =",num1)
}

var num41 = 41
var num42 = 42

swapValues(num1: &num41, num2: &num42)
print(num41,num42)

2、inout参数只能传入可以被多次赋值的

func swapValues2(num:inout Int){
    num = 90
}
var array = [10,20,30]
swapValues2(num: &array[0])
print(array)

3、实现两个数交换可以使用元组

func swapValues3(num1:inout Int,num2:inout Int){
    (num2,num1) = (num1,num2)
}

var num43 = 43
var num44 = 44
swapValues3(num1: &num43, num2: &num44)
print(num43,num44)

函数重载

函数重载
注意与函数重写的区别

1、函数名相同
参数个数不同||参数类型不同||参数标签不同
构成重载

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

//返回值类型与函数重载无关
func sum(_ num1:Int,_ num2:Int,_ num3:Int){
        print(num1 + num2 + num3)
}

let result = sum(1,2)
print("result = ",result)
sum(1,2,3);

2、尽量不要写出这种函数重载

func sum(num1:Int,num2:Int){
    print("num1 = ",num1,"num2 = ",num2)
}

func sum(num3:Int,num4:Int){
    print("num3 = ",num3,"num4 = ",num4)
}

sum(num1: 1, num2: 2)
sum(num3: 3, num4: 4)

3、参数默认值可能引起二义性

func sum(_ num1:Int,_ num2:Int){
    print(num1,num2)
}

func sum(_ num1:Int,_ num2:Int,_ num3:Int = 3){
    print(num1,num2,num3,separator:"-")
}

sum(1, 2)

4、可变参数可能引起二义性

func sum(_ num1:Int,_ num2:Int){
    print("num1,num2")
}

func sum(_ numbers:Int...){
    print("可变参数")
}
sum(1, 2)

内联函数

release模式会有内联的优化

1、内联函数示例1

func test6(){
    print("test6")
}
test6();

//编译器会优化为
//print("test6")

2、内联函数示例2

func add6(a:Int,b:Int)->Int{
    return a+b
}
let c = add6(a: 1, b: 2)

//编译器会优化为
//let c = 3

3、@inline

//永远不会被内联（即使开启了编译器优化）
@inline(never) func test63(){
    print("test")
}

//开启编译器优化，即使代码很长，也会被内联（递归调用函数、动态派发的函数除外）
@inline(__always) func test64(){
    print("test")
}

函数类型

1、函数类型

//函数的类型是 （Int,Int)->Int
func sum7(a:Int,b:Int)->Int{
    return a+b
}

let fn:(Int,Int)->Int = sum7
print(fn(2,3))

2、函数类型作为参数

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

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

func calculate(num1:Int,num2:Int, sumFunc:(Int,Int)->Int,subFunc:(Int,Int)->Int){
    let sumResult = sumFunc(num2,num1)
    print("sumResult = ",sumResult);
    
    let subResult = subFunc(num2,num1)
    print("subResult = ",subResult)
}

calculate(num1: 20, num2: 10, sumFunc: sum, subFunc: sub)

3、函数类型作为返回值

func next7(_ input:Int)->Int{
    input+1
}

func previous7(_ input:Int)->Int{
    input-1
}

//返回值是函数类型的函数 叫做高阶函数
func forward7(_ forward:Bool) -> (Int)->Int{
    forward ? next7:previous7
}

let next = forward7(true)(3)
let previous = forward7(false)(3)
print(next,previous)

typealias

func typealiasUse(){
    /**
     起别名
     */

    typealias Byte = Int8
    typealias Short = Int16
    typealias Long = Int64

    typealias IntFn = (Int,Int)->Int

    //按照swift标准库的定义 Void就是空元祖()
    //public typealias Void = ()
}

嵌套函数

func nestFunctionUse(){
    func forward9(forward:Bool) -> (Int)->Int{
        
        func next(input:Int)->Int{
            input+1
        }
        
        func previous(input:Int)->Int{
            input-1
        }
        
        return forward ? next:previous
    }

    print(forward9(forward: true)(3))
}

行者常至，为者常成！

JHHK