Swift中的closure类型与func的关系

前端之家收集整理的这篇文章主要介绍了Swift中的closure类型与func的关系前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

Swift中的closure是一个类型,关于closure,可以把它与函数做类比

closure在Swift是一个无名函数,类似地,block也是一个匿名函数

注:本篇文章学习自泊学(boxueio.com)



func函数

1. 通过参数处理数据

1)带两个以上参数时

func mul( /*outName*/a:Int,/*outName*/b:Int)
{
    print("\(a) * \(b) = \(a*b)")
}

mul(a: 5,b: 10)
如果不想用outName,则用 “_” 代替
func mul( _ a:Int,_ /*outName*/b:Int) -> (Int)
{
    print("\(a) * \(b) = \(a*b)") 
    return a*b
}

//mul(a: 5,b: 10)
mul(5,10)                // 50




2)参数数量可变时

func arraySum(num:Double...)
{
    var sum: Double = 0.0
    for i in num
    {
        sum+=i
    }
    print("sum:\(sum)")
}

arraySum(num: 1,2,3,4,5,6)
类似于 num: [Double] 接收了一数组
func testSum(num:[Double])
{
    var sum: Double = 0.0
    for i in num
    {
        sum+=i
    }
    print("sum:\(sum)")
}

testSum(num: [1,6])


3)当需要对传入的参数做修改

① 即需要对函数内的参数的修改,要在函数外生效:---> 使用 inout 关键字

func increment( value:inout Int)
{
    value += 1
}

var m = 10;
increment(value: &m)  // 注意:1️⃣
m                     // 11

注意:1️⃣ 此处要传的是一变量值的引用 即传址,而不是它本身 不是传值

 
     
   

② 感觉看起来是不是有点像__block关键字?

typedef void (^myBlock)(void);

int main(int argc,const char * argv[]) {
    @autoreleasepool {
        
        // block
        __block int b = 20;
        
        myBlock block;
        block = ^(void){
            b++;
        };
        
        block();
        printf("b = %d\n",b);   // b = 21
    }
    return 0;
}

4)函数类型做参数

函数类型

//var f1: (Int,Int) -> (Int) = mul
// 或者
var f1 = mul
var f2 = table
var f3 = strToInt
然后可以直接用f1调用函数

f1(5,4)                // 20

函数类型做参数

func myTest( fn: ((String) -> Int?),str: String)
{
    fn(str)             // 20
}
myTest(fn: f3,str: "20")

2. 通过返回值处理数据

1)返回一个值

func multiple(a:Int,andB:Int) ->Int
{
    return a * andB
}
var r = multiple(a: 5,andB: 10)

2)返回多个值,用tuple

func tableInfo() ->(row:Int,colun:Int)
{
    return (4,5)
}

var table = tableInfo()
table.row       // 4
table.colun     // 5

3)返回值可能为空时,用optional

func strToInt(str:String) ->Int?
{
    return Int(str)
}
var n = strToInt(str: "12")     // 12
type(of: n)                     // Optional<Int>.Type
n = strToInt(str: "sd ")        // nil

4)函数类型做返回值

func fun_1(n:Int)->Int
{
    return n+1
}
func test() -> (Int) -> Int
{
    return fun_1(n:)
}
test()

5)内嵌函数

直接把刚刚的fun_1剪切到test函数里面

上面的代码可改成

func test() -> (Int) -> Int
{
    func fun_1(n:Int)->Int
    {
        return n+1
    }
    
    return fun_1(n:)
}
test()

closure

closure与函数func的关系,类似于: let ten = 10

ten为有名常量,10是无名的

closure就类似为一个无名函数


1. closure的使用及简化

1)使用

var addClosure:(Int,Int)->Int = {(a:Int,b:Int) -> Int in
    return a+b
}

addClosure(5,10)

2)简化

1 ∵ 函数类型已经声明过, ∴ 可省略

addClosure = {a,b in return a + b}

2 如果closure的功能可以写成单一表达式,则上式可再简化成

addClosure = {a,b in a - b}

3 甚至可以用符号代替参数

addClosure = {$0 + $1}

2. closure做参数

1)closure做参数时,可以与函数函数的参数时的情况做比较

2)函数类型做参数:

func execute(_ a:Int,_ b:Int,operation:(Int,Int) -> Int) ->Int
{
    return operation(a,b)
}

func addFunc(a:Int,b:Int) ->Int
{
    return a + b
}

execute(10,15,operation: addFunc)       // 25

3)closure类型做参数时:

① 可以直接把之前定义的addClosure传给函数

execute(10,operation: addClosure)     // 25

② 也可以再参数的位置再写一个closure:

execute(10,operation: { (a:Int,b:Int) -> Int in
    return a + b                           // 25
})

tips: 直接在函数参数的位置敲回车 即是一个closure (是不是和block很像)

此时的closure同样可以简化:

execute(6,8,operation: {a,b in a + b})
execute(6,operation: {$0 + $1})
特别地:如果closure做参数的最后一个参数时,可以把closure放在参数列表()外:

execute(6,8){$0 + $1}
原文链接:https://www.f2er.com/swift/321547.html

猜你在找的Swift相关文章