手把手教您打包一个轻易的iOS,0下闭包语法汇总
分类:计算机编程

依赖 Alamofire 的叁个网络央求的包裹,包括闭包回调 和 成功或战败代理方法!

前言

近日在研商AFN的完毕格局,发掘它应用block替代了代办的办法,将种种网络央求的逐条阶段都构成在一块儿,使得代码越发简洁易读,于是小编也参照它的艺术尝试用swift封装了三个基于NSURLSession的互联网诉求,实现了一部分简易意义。

一、闭包的定义

有oc基础的都掌握,闭包其实是oc里面包车型大巴block,语法格式不平等,但效果与利益是均等的。首假设用以callBack(异步回调)也许多少个类之间的通讯。它的真相叁个函数,一个可施行的代码块,只是这一个函数是不曾名字的,也正是无名氏函数。你也能够把他看作如 int、float同样,是一种数据类型,一种能够看做参数字传送递的数据类型。

图片 1图表来源互连网

艺术一:乞求后的闭包回调

知识策动

从前有须要掌握一些有关NSURLSession的相干文化,作者在iOS互联网-NSU逍客LSession简单利用中简易总计了有个别,更详尽的材质可以看看URL Session Programming Guide

二、基本语法

1、闭包的宣示

//定义一个求和闭包
//闭包类型:(Int,Int)->(Int)
  let add:(Int,Int)->(Int) = { (a,b) in
      return a   b;
  }
//执行闭包,相当于调用函数 
let result = add(1100, 200);
//打印闭包返回值
print("result=(result)");

闭包类型是由参数重返值决定,如上述add闭包类型为(Int,Int)->(Int),箭头前面括号是参数类型,八个参数逗号隔断,箭头前面括号重临值类型。

解析下方面代码,“=”左侧的“ let add:(Int,Int)->(Int) ”意思是宣称二个add常量,add是四个闭包类型,而且这一个闭包的项目是:(Int,Int)->(Int)。

“=”左侧是一个代码块,即闭包的实际贯彻,约等于给侧面add常量赋值。代码块的语法格式:

{ (参数1,参数2) in
       //code
}

参数和需实行的代码(code)用 关键字“in”隔开,假使闭包没有参数, “ () in”能够直接省略:

{
    //code
 }

您也得以用关键字“typealias”先声爱他美个闭包的数据类型

import UIKit

//声明一个闭包类型 AddBlock
typealias AddBlock = (Int,Int)->(Int);

class ViewController: UIViewController {

    override func viewDidLoad() {
       super.viewDidLoad()
       let add:AddBlock = { (a,b) in
            return a   b;
       }
       let result = add(1100, 200);
       print("result=(result)");
  }
}

一、闭包的定义

有oc基础的都知情,闭包其实是oc里面包车型大巴block,语法格式不雷同,但效用是一致的。首倘使用于callBack大概多个类之间的通讯。它的精神叁个函数,四个可施行的代码块,只是这么些函数是从未有过名字的,也便是无名氏函数。你也得以把她看作如 int、float同样,是一种数据类型,一种可以视作参数字传送递的数据类型。

/// 闭包回调请求////// - Parameters:/// - method: 请求方式 get、post.../// - url: 可以是字符串,也可以是URL/// - parameters: 参数字典/// - finishedCallback: 完成请求的回调class func request(method:HTTPMethod, url:String, parameters:NSDictionary?, finishedCallback: @escaping (_ result : AnyObject, _ error: Error?) -> { Alamofire.request(url, method: method, parameters: parameters as? Parameters).responseJSON {  in let data = response.result.value if (response.result.isSuccess) { finishedCallback(data as AnyObject, nil) } else { finishedCallback(data as AnyObject,response.result.error) } }}

亟待运用的

率先是伸手情势,使用枚举表示,分别对应get,post等多样办法:

enum Method:String {
    case OPTIONS = "OPTIONS"
    case GET = "GET"
    case HEAD = "HEAD"
    case POST = "POST"
    case PUT = "PUT"
    case PATCH = "PATCH"
    case DELETE = "DELETE"
    case TRACE = "TRACE"
    case CONNECT = "CONNECT"
}

再下来正是供给定义多少个用到的闭包类型

/** 请求成功的回调 */
typealias SucceedHandler = (NSData?, NSURLResponse?) -> Void
/** 请求失败的回调 */
typealias FailedHandler = (NSURLSessionTask?, NSError?) -> Void
/** 下载进度回调 */
typealias DownloadProgressBlock = (NSURLSessionDownloadTask, bytesWritten: Int64, totalBytesWritten: Int64, totalBytesExpectedToWrite: Int64) -> Void
/** 上传进度回调 */
typealias UploadProgressBlock = (NSURLSessionDownloadTask, bytesWritten: Int64, totalBytesWritten: Int64, totalBytesExpectedToWrite: Int64) -> Void
/** 完成下载回调 */
typealias FinishDownloadBlock = (NSURLSessionDownloadTask, distinationURL: NSURL) -> Void
/** 完成任务回调 */
typealias CompletionBlock = (NSURLSessionTask, responseObj:AnyObject?, error: NSError?) -> Void

在类中扬言多少个闭包变量,用于在代理方法中贮存参数,以便于回调

var successHandler:SucceedHandler?
var failHandler:FailedHandler?

var downloadProgressHandler:DownloadProgressBlock?
var uploadProgressHandler:UploadProgressBlock?

var finishHandler:FinishDownloadBlock?
var completionHandler:CompletionBlock?

实例化叁个manager对象,用它来做有所的互联网伏乞操作,外界也是由此manager来调用需要方法,相同的时候创立八个session实例

var session:NSURLSession?

lazy var myQueue:NSOperationQueue = {
    let q = NSOperationQueue()
    q.maxConcurrentOperationCount = 1
    return q
}()

internal static let manager:AHNetworkingManager = {
    let m = AHNetworkingManager()
    return m
}()

override init() {
    super.init()
    session = NSURLSession(configuration: NSURLSessionConfiguration.defaultSessionConfiguration(), delegate: self, delegateQueue: myQueue)
}

三、闭包的用法

1、八个类之间的通讯

ios中类之间的通讯格局有三种,常用的有:公约代理、文告,以及本章要讲的闭包。因为合同代理用起来相比费心,又是宣称合同章程、又要安装代理的,代码步骤太多,笔者一般不要;公告一般用于七个完全没有涉及的类通讯,能够一对多,但解耦和的太厉害,小编一般是特定的场地用。所以本着有关系的多个类之间的通讯,我一般是用闭包或block的,那样相比轻巧神速。

演示程序:监听调节器上多少个自定义view按键的点击

CustomView类中代码

class CustomView: UIView {
    //声明一个属性btnClickBlock,type为闭包可选类型
    //闭包类型:()->() ,无参数,无返回值
    var btnClickBlock:(()->())?;

    //重写 init(frame: CGRect)构造函数
    override init(frame: CGRect) {
       super.init(frame:frame);
        //创建按钮
        let btn = UIButton(frame: CGRect(x: 15, y: 15, width: 80, height: 32));
        btn.setTitle("按钮", for: .normal);
        btn.backgroundColor = UIColor.blue;
        //绑定事件
        btn.addTarget(self, action: #selector(CustomView.btnClick), for: .touchDown);
        //添加
        addSubview(btn);

    }
    //按钮点击事件函数
    func btnClick(){
        if self.btnClickBlock != nil {
            //点击按钮执行闭包
            //注意:属性btnClickBlock是可选类型,需要先解包
            self.btnClickBlock!();
        }
    }

    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

}

Controller类中代码:

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        //创建CustomView对象
        let cutomeView = CustomView(frame: CGRect(x: 50, y: 50, width: 200, height: 200));
        //给cutomeView的btnClickBlock闭包属性赋值
        cutomeView.btnClickBlock = {
           // () in 无参数可以省略
            //当按钮被点击时会执行此代码块
            print("按钮被点击");
        }
        cutomeView.backgroundColor = UIColor.yellow;
        //添加到控制器view上
        self.view.addSubview(cutomeView);
    }
}

2、异步回调(callBack)

以发送多个简短的网络伏乞为例:

/// 定义一个网络请求函数
    ///
    /// - parameter urlString: 请求接口    String
    /// - parameter succeed:   成功的回调  可选闭包
    /// - parameter failure:   失败的回调  可选闭包
    func requestData(urlString:String,succeed: ((Any?)->(Void))?,failure:((Any?)->(Void))?){

        let request = URLRequest(url: URL(string: urlString)!);
        //发送网络请求
        NSURLConnection.sendAsynchronousRequest(request, queue: OperationQueue()) { (_, data, error) in
            if error == nil {
                //请求成功,执行成功的回调,并把数据传递出去
                succeed?(data);
            }else{
                 //请求失败,执行失败的回调,并把错误传递出去
                failure?(error);
            }
        }
    }

// 调用函数requestData函数
        requestData(urlString: "http://www.baidu.com", succeed: { (data) -> (Void) in
            //成功的回调
            guard let result = data as? Data else{
                return;
            }
            let srt =  NSString(data: result, encoding: String.Encoding.utf8.rawValue);
             print(srt!)
            }) { (error) -> (Void) in
                //失败的的回调
               print(error);
        }

二、基本语法

1、闭包的宣示

 //定义一个求和闭包 //闭包类型:-> let add:-> = {  in return a   b; } //执行闭包,相当于调用函数 let result = add(1100, 200); //打印闭包返回值 print("result=;

闭包类型是由参数再次回到值决定,如上述add闭包类型为->,箭头后面括号是参数类型,五个参数逗号隔开分离,箭头前边括号再次来到值类型。

深入分析下方面代码,“=”左侧的“ let add:-> ”意思是宣称二个add常量,add是一个闭包类型,况且那一个闭包的体系是:->。

“=”侧边是多少个代码块,即闭包的具体落实,也正是给侧面add常量赋值。代码块的语法格式:

{  in //code }

参数和需试行的代码用 关键字“in”隔离,假使闭包未有参数, “ () in”能够一向省略:

{ //code }

你也足以用关键字“typealias”先声明一(Wissu)个闭包的数据类型

import UIKit//声明一个闭包类型 AddBlocktypealias AddBlock = ->;class ViewController: UIViewController { override func viewDidLoad() { super.viewDidLoad() let add:AddBlock = {  in return a   b; } let result = add(1100, 200); print("result=; }}

方式二:央求后的代办方法重回

简单的说诉求

先来兑现一个简约的乞请,也便是行使GET获取json可能xml数据之后剖判那类的,能够在伸手成功和停业现在做一些做一些操作,其主要运用的是:

public func dataTaskWithRequest(request: NSURLRequest,
 completionHandler: (NSData?, NSURLResponse?, NSError?) -> Void) -> NSURLSessionDataTask

骨干思路依旧将原来在completionHandler当中的回调传递出去:

//创建一个请求
func createRequest(URLString:String, method:Method) -> (NSMutableURLRequest){
    let request = NSMutableURLRequest(URL: NSURL(string: URLString)!)
    request.HTTPMethod = method.rawValue
    return request
}

//实现方法
func dataTask(method:Method, URLString:String, succeed:SucceedHandler?, failed:FailedHandler?) -> NSURLSessionDataTask {

    let request = createRequest(URLString, method: method)

    var task:NSURLSessionDataTask?
    task = self.session!.dataTaskWithRequest(request) { (data, response, error) -> Void in
        if let e = error {
            NSLog("fail with error:\(e.localizedDescription)")
            if let f = failed {
                f(task,e)
            }
            return
        }
        if let s = succeed {
            s(data, response)
        }
    }

    return task!
}

四、闭包的局地非同一般语法

1、尾随闭包

当闭包作为函数的末尾一个参数时,能够简轻松单前面包车型大巴括号。尾随闭包没什么分外的功能,纯粹是一种语法上的洗练,扩展易读性。

例:定义三个函数:

//第二个参数:闭包  (String)->(Void)
func post(url:String,succesce:(String)->Void) {
   print("发送请求");
   succesce("请求完成");
}

实施函数,不荒谬写法:

//正常写法,第二个参数,传递一个闭包
 post("http", succesce: { (json) in //闭包传递的参数
     //执行的代码
     print(json);
 });

试行函数,尾随闭包写法:

//尾随闭包,当闭包作为函数的最后一个参数时,可以省略前面的括号
  HttpTool.post("http") { (json) in
      print(json);
  };

2、逃逸闭包

看起来很“吊炸天”的三个名字,其实很轻易。当闭包作为二个参数字传送递到函数时,我们了然它一般是用以函数内部的异步回调,闭包是等异步职务实现以往才调用,而函数是会非常的慢推行完结并回到的,所以闭包它供给逃逸,以便稍后的回调。

逃走闭包一般用来异步函数的回调,比如网络乞请成功的回调理退步的回调。语法:在函数的闭包行参前加关键字“@escaping”。

可能稳重的人早就意识本人上面包车型大巴演示网络哀告为啥未有出现重大字“@escaping”,你能够拉回去看下成功回调或停业的回调,类型是“((Any?)->(Void))?”,前面带了个“?”,那是闭包可选类型,而不是闭包类型,所以不必要珍视字“@escaping”。

若果成功和挫败的回调要弄成闭包类型,而你又要异步使用以来,那即将要形参前边加关键字,如下:

/// 定义一个网络请求函数
    ///
    /// - parameter urlString: 请求接口    String
    /// - parameter succeed: 成功的回调  闭包 因需要异步使用,前面加关键字@escaping修饰,指明其为逃逸闭包
    /// - parameter failure: 失败的回调  闭包 因需要异步使用,前面加关键字@escaping修饰,指明其为逃逸闭包
    func requestData(urlString:String,succeed: @escaping (Any?)->(Void),failure:@escaping (Any?)->(Void)){

        let request = URLRequest(url: URL(string: urlString)!);

        //发送网络请求
        NSURLConnection.sendAsynchronousRequest(request, queue: OperationQueue()) { (_, data, error) in
            if error == nil {
                //请求成功,执行成功的回调,并把数据传递出去
                succeed(data);
            }else{
                 //请求失败,执行失败的回调,并把错误传递出去
                failure(error);
            }
        }
    }

假如成功和曲折的回调要弄成闭包类型,而你又要异步使用以来,但您又不想在形参后边加关键字,那对不起,作者也远非议程,编译直接报错!

3、闭包的用法

1、七个类之间的通信

ios中类之间的通讯方式有多样,常用的有:契约代理、文告,以及本章要讲的闭包。因为合同代理用起来相比艰苦,又是宣称左券格局、又要安装代理的,代码步骤太多,笔者一般不要;通告一般用来多个精光未有涉及的类通讯,能够一对多,但解耦和的太厉害,作者一般是一定的场子用。所以针对有关系的七个类之间的通讯,作者一般是用闭包或block的,那样相比精简快速。

示范程序:监听调节器上三个自定义view开关的点击

图片 2分界面效果

CustomView类中代码

class CustomView: UIView { //声明一个属性btnClickBlock,type为闭包可选类型 //闭包类型: ,无参数,无返回值 var btnClickBlock:)?; //重写 init(frame: CGRect)构造函数 override init(frame: CGRect) { super.init(frame:frame); //创建按钮 let btn = UIButton(frame: CGRect(x: 15, y: 15, width: 80, height: 32)); btn.setTitle("按钮", for: .normal); btn.backgroundColor = UIColor.blue; //绑定事件 btn.addTarget(self, action: #selector(CustomView.btnClick), for: .touchDown); //添加 addSubview; } //按钮点击事件函数 func btnClick(){ if self.btnClickBlock != nil { //点击按钮执行闭包 //注意:属性btnClickBlock是可选类型,需要先解包 self.btnClickBlock!(); } } required init?(coder aDecoder: NSCoder) { fatalError("init has not been implemented") }}

Controller类中代码:

class ViewController: UIViewController { override func viewDidLoad() { super.viewDidLoad() //创建CustomView对象 let cutomeView = CustomView(frame: CGRect(x: 50, y: 50, width: 200, height: 200)); //给cutomeView的btnClickBlock闭包属性赋值 cutomeView.btnClickBlock = { // () in 无参数可以省略 //当按钮被点击时会执行此代码块 print; } cutomeView.backgroundColor = UIColor.yellow; //添加到控制器view上 self.view.addSubview(cutomeView); }}

2、异步回调

以发送三个简练的网络央求为例:

/// 定义一个网络请求函数 /// /// - parameter urlString: 请求接口 String /// - parameter succeed: 成功的回调 可选闭包 /// - parameter failure: 失败的回调 可选闭包 func requestData(urlString:String,succeed: ->?,failure:->{ let request = URLRequest(url: URL(string: urlString)!); //发送网络请求 NSURLConnection.sendAsynchronousRequest(request, queue: OperationQueue { (_, data, error) in if error == nil { //请求成功,执行成功的回调,并把数据传递出去 succeed?; }else{ //请求失败,执行失败的回调,并把错误传递出去 failure?; } } }

// 调用函数requestData函数 requestData(urlString: "http://www.baidu.com", succeed: {  ->  in //成功的回调 guard let result = data as? Data else{ return; } let srt = NSString(data: result, encoding: String.Encoding.utf8.rawValue); print {  ->  in //失败的的回调 print; }
/// 代理方法请求////// - Parameters:/// - method: 请求方式 get、post.../// - url: 可以是字符串,也可以是URL/// - requestName: 请求名字,一个成功的代理方法可以处理多个请求,所以用requestName来区分具体请求/// - parameters: 参数字典/// - delegate: 代理对象class func requestDelegate(method:HTTPMethod, url:String, requestName:String, parameters:NSDictionary?, delegate:AnyObject){ let config:URLSessionConfiguration = URLSessionConfiguration.default config.timeoutIntervalForRequest = NetworkTimeoutInterval sessionManager = SessionManager(configuration: config) Alamofire.request(url, method: method, parameters: parameters as? Parameters).responseJSON {  in let data = response.result.value if (response.result.isSuccess) { delegate.netWortDidSuccess?(result: data as AnyObject, requestName: requestName, parameters: parameters) } else { delegate.netWortDidFailed?(result: data as AnyObject, error:response.error, requestName: requestName, parameters: parameters) } }}@objc protocol WRNetWrapperDelegate:NSObjectProtocol{ // TODO:研究 如果把result的类型改为Any会怎么样 @objc optional func netWortDidSuccess(result:AnyObject, requestName:String, parameters:NSDictionary?); @objc optional func netWortDidFailed (result:AnyObject, error:Error?, requestName:String, parameters:NSDictionary?);}

下载诉求

金玉锦绣下载供给比较复杂一些,代理方法中的参数需求传递出去,同不时间因为session是三个异步操作,有时需求拭目以俟某个数据重回之后才将其传递出去,不然就能够冒出岂有此理的结果。

先将回调方法用全局变量保存起来,在代理方法中传送参数

private func downloadTask(method:Method,URLString:String,
            downloadProgress:DownloadProgressBlock?,uploadProgress:UploadProgressBlock?,    
            finish:FinishDownloadBlock?, completion:CompletionBlock?) -> NSURLSessionDownloadTask {

    let request = createRequest(URLString, method: method)
    let task = self.session!.downloadTaskWithRequest(request)

    if let d = downloadProgress {
        self.downloadProgressHandler = d
    }

    if let f = finish {
        self.finishHandler = f
    }

    if let c = completion {
        self.completionHandler = c
    }

    return task
}

completion本条block中依据再次来到的error是或不是为空来决定是或不是调用succeedHandler回调:

private func downloadTask(method:Method,
    URLString:String,
    succeed:SucceedHandler?,
    failed:FailedHandler?,
    downloadProgress:DownloadProgressBlock?,
    uploadProgress:UploadProgressBlock?,
    finish:FinishDownloadBlock?) -> NSURLSessionDownloadTask {

    let task = downloadTask(method,URLString: URLString,
        downloadProgress: downloadProgress,uploadProgress: nil,
        finish: finish,completion:{ (task,respobseObj:AnyObject?, error) -> Void in

        if error != nil {
            NSLog("fail with error:\(error)")
            if let f = failed {
                f(task,error)
            }
            return
        }
        if let s = succeed {
            s(respobseObj as? NSData,task.response)
        }
    })

    return task
}

接下去就是多少个代理方法中的处理,有一点急需留心,由于succeedHandler亟待获得responseObjerror五个参数分别是在

func URLSession(session: NSURLSession, downloadTask: NSURLSessionDownloadTask, didFinishDownloadingToURL location: NSURL)

func URLSession(session: NSURLSession, task: NSURLSessionTask, didCompleteWithError error: NSError?)

这五个不一样的代办方法中,所以本人这里的管理是在didFinishDownloadingToURL办法大校获得的responseObj用七个全局变量存起来,然后利用队列组的等候功效再在didCompleteWithError方法中的回调self.compleHandler

let group = dispatch_group_create()
let queue = dispatch_get_global_queue(0, 0)

 func URLSession(session: NSURLSession, downloadTask: NSURLSessionDownloadTask, didFinishDownloadingToURL location: NSURL) {
    let distination = savePathForDownloadData(location, task: downloadTask)
    NSLog("distination:\(distination)")
    if let finish = self.finishHandler {
        finish(downloadTask, distinationURL: distination)
    }
    dispatch_group_async(group, queue) { () -> Void in
        self.responseObj = NSData(contentsOfURL: distination)
    }

}

func URLSession(session: NSURLSession, task: NSURLSessionTask, didCompleteWithError error: NSError?) {

    dispatch_group_notify(group, queue) { () -> Void in
        if let complete = self.completionHandler {
            complete(task, responseObj: self.responseObj, error: error)
        }
    } 
}

//MARK: save downloaded data then return save path
func savePathForDownloadData(location:NSURL, task:NSURLSessionDownloadTask) -> NSURL {
    let manager = NSFileManager.defaultManager()
    let docDict = manager.URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask).first
    let originURL = task.originalRequest?.URL
    let distinationURL = docDict?.URLByAppendingPathComponent((originURL?.lastPathComponent)!)

    do{
        try manager.removeItemAtURL(distinationURL!)
    }catch{
        NSLog("remove failed")
    }

    do{
        try manager.copyItemAtURL(location, toURL: distinationURL!)
    }catch{
        NSLog("copy failed")
    }

    return distinationURL!
}

落到实处最后二个下载速度的回调

func URLSession(session: NSURLSession, downloadTask: NSURLSessionDownloadTask, didWriteData bytesWritten: Int64, totalBytesWritten: Int64, totalBytesExpectedToWrite: Int64) {
    let p = Float(totalBytesWritten) / Float(totalBytesExpectedToWrite)
    NSLog("progress:\(p)")

    if let progressHandler = self.downloadProgressHandler {
        progressHandler(downloadTask,bytesWritten: bytesWritten,totalBytesWritten: totalBytesWritten, totalBytesExpectedToWrite: totalBytesExpectedToWrite)
    }
}

四、闭包的一部分极其语法

1、尾随闭包

当闭包作为函数的结尾贰个参数时,能够总结前边的括号。尾随闭包没什么极度的职能,纯粹是一种语法上的简要,扩展易读性。

例:定义二个函数:

//第二个参数:闭包 ->func post(url:String,succesce:->Void) { print; succesce; }

实行函数,通常写法:

 //正常写法,第二个参数,传递一个闭包 post("http", succesce: { //闭包传递的参数  in //执行的代码 print;

实行函数,尾随闭包写法:

//尾随闭包,当闭包作为函数的最后一个参数时,可以省略前面的括号 HttpTool.post {  in print; };

2、逃逸闭包

看起来很“吊炸天”的三个名字,其实很轻松。当闭包作为多少个参数字传送递到函数时,大家明白它一般是用来函数内部的异步回调,闭包是等异步职责达成今后才调用,而函数是会飞快实行实现并回到的,所以闭包它须要逃逸,以便稍后的回调。

逃跑闭包一般用来异步函数的回调,比方互联网央浼成功的回调养倒闭的回调。语法:在函数的闭包行参前加关键字“@escaping”。

或然稳重的人曾经意识本身下边包车型客车言传身教网络央求为啥未有出现根本字“@escaping”,你能够拉回去看下成功回调或战败的回调,类型是“->?”,前边带了个“?”,这是闭包可选类型,并非闭包类型,所以无需重视字“@escaping”。

假若成功和波折的回调要弄成闭包类型,而你又要异步使用的话,那将在要形参前面加关键字,如下:

 /// 定义一个网络请求函数 /// /// - parameter urlString: 请求接口 String /// - parameter succeed: 成功的回调 闭包 因需要异步使用,前面加关键字@escaping修饰,指明其为逃逸闭包 /// - parameter failure: 失败的回调 闭包 因需要异步使用,前面加关键字@escaping修饰,指明其为逃逸闭包 func requestData(urlString:String,succeed: @escaping ->,failure:@escaping ->{ let request = URLRequest(url: URL(string: urlString)!); //发送网络请求 NSURLConnection.sendAsynchronousRequest(request, queue: OperationQueue { (_, data, error) in if error == nil { //请求成功,执行成功的回调,并把数据传递出去 succeed; }else{ //请求失败,执行失败的回调,并把错误传递出去 failure; } } }

借使成功和挫败的回调要弄成闭包类型,而你又要异步使用以来,但您又不想在形参前面加关键字,那对不起,俺也并未有主意,编写翻译间接报错!

代理重回情势

实际使用

一言以蔽之包装之后,使用简易央求的时候就可怜便捷了,没有须求重写一批的代办方法,只须求在写好须求成功和退步的操作就行了:

let manager = AHNetworkingManager.manager
manager.get(URLString, succeed: { (data:NSData?, response:NSURLResponse?) -> Void in

        let arr = self.parseResponse(data!, response: response!)
        for dic in arr {
            let model = Model(dic: dic)
            self.models.append(model)
        }
        dispatch_async(dispatch_get_main_queue(),{ Void in
            self.tableView.reloadData()
        })

    }, failed: {(task,error) -> Void in
        NSLog("请求失败,reason:\(error?.localizedDescription)")
})

福寿绵绵下载文件功用:

let manager = AHNetworkingManager.manager
downloadTask = manager.get(URLString, finish: { (task, distinationURL) -> Void in

        self.imgPath = distinationURL

        assert(self.imgPath.absoluteString.characters.count>0, "imgPath is not exit")

        NSLog("download completed in path:\(self.imgPath)")
        let data = NSData(contentsOfURL: self.imgPath)
        let img = UIImage(data: data!)
        dispatch_async(dispatch_get_main_queue()) { () -> Void in
            self.imageView.image = img
        }

    }, failed: {(task,error) -> Void in

        NSLog("下载失败,reason:\(error?.localizedDescription)")

    },downloadProgress: { (task, bytesWritten, totalBytesWritten, totalBytesExpectedToWrite) -> Void in

        let p = Float(totalBytesWritten) / Float(totalBytesExpectedToWrite)
        dispatch_async(dispatch_get_main_queue()) { () -> Void in
            self.progress.text = "\(p)"
            self.progressBar.progress = p
        }
        NSLog("progress:\(p)")       
})

可以把这几个小demo下下来跑看看,倘若对你有援助,还望不吝啬你的star

let requestSplashImage = "requestSplashImage"// 网络请求,就这么简单WRApiContainer.requestSplashImage(delegate: self)// 网络请求成功func netWortDidSuccess(result: AnyObject, requestName: String, parameters: NSDictionary?){ if (requestName == requestSplashImage) { // 请求 requestSplashImage 对应的成功返回 }}// 网络请求失败func netWortDidFailed(result: AnyObject, error:Error?, requestName: String, parameters: NSDictionary?){}

闭包回调格局

let urlStr = "http://news-at.zhihu.com/api/7/prefetch-launch-images/1080*1920"WRNetWrapper.request(method: .get, url: urlStr, parameters: nil){ [weak self] (result, error) in if let weakSelf = self { if (error == nil) { // 请求成功 } else { // 请求失败 } }}

demo地址:

招待关心自身的天涯论坛:wangrui460

本文由pc28.am发布于计算机编程,转载请注明出处:手把手教您打包一个轻易的iOS,0下闭包语法汇总

上一篇:字符串和字符 下一篇:没有了
猜你喜欢
热门排行
精彩图文