Swift 用Delegate和Block实现回调的Demo

1、有关回调

咱们知道，执行函数的时候，通常都有return做为返回参数了，那有return了为何还要回调呢？

回调是为了实现异步的返回，在某些特殊的状况下，好比你执行的函数是一个长时间运行的函数，并不能直接返回给你结果，为了避免影响源程序其余步骤的执行，你得继续执行下去，等那边产生结果了再“主动告诉你”结果是什么。

其原理不外乎：A调用B中函数，传递参数和自身指针，B执行完成再经过传递过来的指针从新调用A中函数。

在iOS开发中，实现回调的方式有：Delegate和Block。前者用变量指针实现，后者用函数指针实现。

假如我如今有一个processData的类用来处理数据，处理完以后回调给主要的Class。

 

2、Swift中实现回调

1.代理模式：利用protocol+引用变量

processData.swift

//
//  ProcessData.swift

import UIKit
//定义协议
protocol callBackDelegate {
    func callbackDelegatefuc(backMsg:String)
}

class ProcessData: NSObject{
    //定义一个符合改协议的代理对象
    var delegate:callBackDelegate?
    func processMethod(cmdStr:String?){
        if((delegate) != nil){
            delegate?.callbackDelegatefuc("backMsg---by delegate")
        }
    }
}

ViewController.swift

//
//  ViewController.swift

import UIKit

//继承该协议
class ViewController: UIViewController,callBackDelegate{
    
    override func viewDidLoad() {
        super.viewDidLoad()
        let process=ProcessData()

        //把process的delegate变量指针指向本身，那样process就能调用本身类里的函数了
        process.delegate=self

        //执行函数
        process.processMethod("startProcess")
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
    }
    
    //delegate回调
    func callbackDelegatefuc(backMsg:String){
        print(backMsg)
    }
}

 

2.利用闭包实现：

闭包在Objective-C中被称为Block，在Swift中被成为Closure(在Java中称为Lambda)

   2.1利用闭包变量实现回调

processData.swift

//
//  ProcessData.swift

import UIKit

class ProcessData: NSObject{
    //定义block
    typealias fucBlock = (backMsg :String) ->()
    //建立block变量
    var blockproerty:fucBlock!
    
    func processMethod(cmdStr:String?){
        if let _ = blockproerty{
            blockproerty(backMsg: "backMsg---by block property")
        }
    }
}

ViewController.swift

//
//  ViewController.swift

import UIKit

class ViewController: UIViewController{
    
    override func viewDidLoad() {
        super.viewDidLoad()
        let process=ProcessData()
        
        //block回调
        process.blockproerty={ (backMsg) in
            print(backMsg)
        }
        
        //执行函数
        process.processMethod("processStart")
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
    }
}

  2.2 把闭包写入函数做参数实现快速回调，可见这是一种代码最为简洁的方案

processData.swift

//
//  ProcessData.swift

import UIKit

class ProcessData: NSObject{
    //定义block
    typealias fucBlock = (backMsg :String) ->()

    func processWithBlock(cmdStr:String?,blockProperty:fucBlock){
        blockProperty(backMsg :"backMsg---by block inside func")
    }
}

ViewController.swift

//
//  ViewController.swift

import UIKit

class ViewController: UIViewController{
    
    override func viewDidLoad() {
        super.viewDidLoad()
        let process=ProcessData()

        //函数内回调
        process.processWithBlock("bbb") { (backMsg) in
            print(backMsg)
        }
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
    }
}

 

PS：若是Block带返回值的状况下，Block是这样定义和调用的

//定义block
    typealias fucBlock = (backMsg :String) ->(String)

 

//函数内回调
        process.processWithBlock("bbb") { (backMsg) ->(String) in
            print(backMsg)
            return "get msg"
        } 

 

 2.3.刚使用的typealias把block给定义给一个变量了，如今直接代替进去就能够了，而且我给函数再加个String类型返回值。。

processData.swift

func processWithBlock(cmdStr:String?,blockProperty:(backMsg :String) ->())->(String){
        blockProperty(backMsg :"backMsg---by block inside func")
        return ""
    }

 

 

 

swift:https://github.com/rayshen/SwiftClosure

oc:https://github.com/rayshen/callbackDemo