iOS学习笔记42-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是看似的。
闭包的特性就是可以捕获和仓储上下文中的常量或者变量的引用,即便那些常量或者变量在原功效域已经被灭绝了在代码块中仍是可以选用。

在斯威夫特中闭包表明式的定义格局如下:
{ ( 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. 跟随闭包
//尾随闭包
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哈!