C语言iOS学习笔记42-Swift(二)函数和闭包

齐亦然省咱们说话了Swift的根基部分,例如数据类型、运算符和控制流等,现在我们来拘禁下Swift的函数和闭包

一、Swift函数

函数是一个好独立任务的代码块,Swift惨遭的函数不仅可像C语言中之函数一样当函数的参数与归值,而且还支持嵌套,支持函数参数默认值、可易参数等。

/**
* 1、函数第一个参数默认没有外部参数名,其他参数默认有
* 2、可变参数只能在最后一个参数,可变参数的类型是数组
* 3、返回类型也可以是元组
* 4、可以在参数前面加inout关键字,表示内部修改会改变外部的变量,调用时要加“&”符号
* 5、Swift中的函数本身也可以看做一种类型,既可以作为参数又可以作为返回值。
     例如 var fun:(Int,Int)->(Double,Int) = fun2
*/
func 函数名(参数1:类型1, inout 参数2:类型2=默认值2, 可变参数3:类型3...) -> 返回值类型 {

    函数体

    return 返回值
}
函数实例:
1. 平淡无奇函数
//1. 定义一个函数,注意参数和返回值,如果没有返回值可以不写返回值或者写成Void、空元组()
func mySum(num1:Int, num2:Int) -> Int{
    return num1 + num2
}
//调用函数,num2是外部参数名,函数第一个参数默认没有外部参数名,其他参数默认有
mySum(1, num2: 2)
2. 装外部参数称为
/**
*  2. 函数参数名分为局部参数名和外部参数名
*/
func mySplit(string a:String, seperator b:Character) -> [String]{
    return ["hello", "world", "!"]
}
/* 
由于给mySplit函数设置了外部参数名string和seperator,所以执行的时候必须带上外部参数名,
此处可以看到一个有意义的外部参数名大大节省开发者使用成本
 */
mySplit(string: "hello,world,!", seperator: ",") //结果:["hello", "world", "!"]
3. 安装默认参数值
//3. 设置函数的最后一个参数默认值设置为",",注意如果使用默认参数那么此参数名将默认作为外部参数名
func mySplit3(string:String, seperator:Character=",")->[String]{
    return ["hello", "world", "!"]
}
mySplit3("hello,world,!") //结果:["hello", "world", "!"]
mySplit3("hello world !", seperator: " ") //结果:["hello", "world", "!"]
4. 装置可换参数
/**
 * 4. 可变参数,一个函数最多有一个可变参数并且作为最后一个参数
 * 下面strings参数在内部是一个[String],对于外部是不定个数的String参数
 */
func myJoinStr(seperator seperator:Character=",", strings:String...) -> String{
    var result:String = ""
    for var i = 0;i < strings.count; ++i{
        if i != 0{
            result.append(seperator)
        }
        result += strings[i]
    }
    return result
}
//调用
myJoinStr(seperator:" ", strings: "hello","world","!") //结果:"hello world !"
5. 设置输入输出参数
/**
 *  5. 输入输出参数
 *  通过输入输出参数可以在函数内部修改函数外部的变量(注意调用时不能是常量或字面量)
 *  注意:下面的mySwap仅仅为了演示,实际使用时请用Swift的全局函数swap
 */
func mySwap(inout a:Int ,inout b:Int){
    a = a + b
    b = a - b
    a = a - b
}
var a = 1,b = 2
mySwap(&a, b: &b) //调用时参数加上“&”符号
print("a=\(a),b=\(b)") //结果:"a=2,b=1"
6. 函数类型使用
/**
 * 6. 函数类型
 */
var sum3 = mySum //自动推断sum3的类型:(Int,Int)->Int,注意不同的函数类型之间不能直接赋值
sum3(1,num2: 2) //结果:3

//函数作为返回值
func fn() -> (Int,Int)->Int{
    //下面的函数是一个嵌套函数,作用于是在fn函数内部
    func minus(a:Int, b:Int) -> Int{
        return a - b
    }
    return minus;
}
var minus = fn()
minus(1,2) //结果:-1

//函数作为参数
func caculate(num1:Int,num2:Int,fn:(Int,Int)->Int) -> Int{
    return fn(num1,num2)
}
caculate(1,num2: 2,fn: mySum) //结果:3
caculate(1,num2: 2,fn: minus) //结果:-1

二、闭包

Swift着的闭包其实就是一个函数替码块,它和ObjC中的Block及Java中的lambda大凡类似之。
闭包的特点就是是足以捕获和贮上下文中的常量或者变量的援,即使这些常量或者变量在原作用域已经深受销毁了当代码块被依然可用。

每当Swift中闭包表达式的概念形式如下:
{ ( parameters ) -> returnType in 
    statements;
}
闭包使用:
1. 免动闭包,使用函数
func mySum(num1:Int,num2:Int) -> Int{
    return num1 + num2
}
func myMinus(num1:Int,num2:Int) -> Int{
    return num1 - num2
}
func myCaculate(num1:Int, num2:Int, fn:(Int,Int)->Int) -> Int{
    return fn(num1,num2)
}
var (a, b) = (1, 2)
myCaculate(a, num2: b, fn: mySum) //结果:3
myCaculate(a, num2: b, fn: myMinus) //结果:-1
2. 采用闭包
//利用闭包表达式替代函数mySum
myCaculate(a, num2: b, fn: {(num1:Int, num2:Int) -> Int in
    return num1 + num2
}) //结果:3
//利用闭包表达式替代函数myMinus
myCaculate(a, num2: b, fn: {(num1:Int, num2:Int) -> Int in
    return num1 - num2
}) //结果:-1
3. 闭包的简化形式
//简化形式,根据上下文推断类型并且对于单表达式闭包(只有一个语句)可以隐藏return关键字
myCaculate(a, num2: b, fn: { num1, num2 in
    num1 + num2
}) //结果:3
myCaculate(a, num2: b, fn: { num1, num2 in
    num1 - num2
}) //结果:-1
4. 闭包继续简化,使用参数缩写
//再次简化,使用参数名缩写,使用$0...$n代表第n个参数,并且此in关键字也省略了
myCaculate(a, num2: b, fn: { $0 + $1 }) //结果:3
myCaculate(a, num2: b, fn: { $0 - $1 }) //结果:-1

考虑到闭包表达式的而读取性,Swift饱受一旦一个函数的末尾一个参数是一个函数类型的参数(或者说是闭包表达式),则可将这个参数写在部数括哀号之后,这种闭包称之为“尾随闭包”

5. C语言随行闭包
//尾随闭包
myCaculate(a,num2: b) { 
    $0 + $1
} //结果:3
myCaculate(a,num2: b) { 
    $0 - $1 
} //结果:-1
6. 捕获变量

前说罢闭包之所以称为“闭包”,就是以该可捕获一定作用域内的常量或者变量进而闭合并包裹在。

func myAdd() -> ()->Int {
    var total = 0
    var step = 1
    func fn() -> Int{
        total += step
        return total
    }
    return fn
}
/* 
fn捕获了total和step,尽管下面的myAdd()执行完后total和step被释放,
但是由于fn捕获了二者的副本,所以fn会随着两个变量的副本一起被存储
 */
var a = myAdd()
a() //结果:1
a() //结果:2,说明a中保存了total的副本(否则结果会是1)

var b = myAdd()
b() //结果:1,说明a和b单独保存了total的副本(否则结果会是3)

var c = b
c() //结果:2,说明闭包是引用类型,换句话说函数是引用类型(否则结果会是1)
  • Swift见面自行决定捕获变量或者常量副本的拷贝类型(值拷贝或者引用拷贝)而休欲开发者关心
  • 被破获的变量或者常量的内存管理均等是由于Swift来治本,我们不用关心,例如当上面的函数a不再采用了,那么fn捕获的一定量单变量也就算释放了。
发出什么问题在凡评论区中提出!O(∩_∩)O哈!