探究 Promise 对象

login()
.then {

    // our login method wrapped an async task in a promise
    return API.fetchKittens()

}.then { fetchedKittens in

    // our API class wraps our API and returns promises
    // fetchKittens returned a promise that resolves with an array of kittens
    self.kittens = fetchedKittens
    self.tableView.reloadData()

}.error { error in

    // any errors in any of the above promises land here
    UIAlertView(…).show()

}

构造 Promise 对象

AWPromise<NSData>(block: { (resolve, reject) in
            print("start")
            dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), {
                print("wait")
                NSThread.sleepForTimeInterval(3.0)
                dispatch_sync(dispatch_get_main_queue(), {
                    print("wait complete")
                    resolve(NSData())
                })

            })
        })

typealias ResolveFunc = (T) -> ()
typealias RejectFunc = (NSError) -> ()
typealias PromiseBlock = (resolve:ResolveFunc,reject:RejectFunc) -> ()
/// 用来保存后续操作
var f_then : ResolveFunc? = nil
/// 用来保存错误处理
var f_error : RejectFunc? = nil
/// 状态
var state:AWPromiseState = .Panding
/// 运行的结果
var result : AWResult<T>? = nil
init(@noescape block:PromiseBlock){
    block(resolve: { (t) in
        self.complete(t)
    }) { (error) in
        self.fail(error)
    }
}
func complete(t:T) -> () {
    self.result = AWResult.Success(t)
    state = .FullFilled
    f_then?(t) /// 如果 promise 内是同步函数， f_then 是还未被赋值时就被 complete 调用的
}
func fail(error:NSError) -> () {
    self.result = AWResult.Error(error)
    state = .Rejected
    f_error?(error)
}

Promise 对象的状态

• Panding: 刚开始构造函数，其中的闭包还没完成的时候

• FullFilled: 操作完成了；

• Rejected: 操作完成但是出错了；

为什么可以实现联级调用

• 构造 Promise 对象时传入异步代码块;

• 调用 then 方法为当前的 Promise 对象保存下一步需要操作的代码块，同时他返回一个新的 Promise 对象，并重复这一过程；

• 每个 Promise 对象的代码块执行完成的时候，他会调用 f_then 操作后面的过程。

then 中嵌套另一个异步过程的情况

func then<U>(f: (T throws -> U)) -> AWPromise<U>
func then<U>(f : (T throws -> AWPromise<U>)) -> AWPromise<U>

then 内包含非异步代码怎么办

错误处理

.error { (error) in
            print("\\(error.domain)")
}

AWPromise<NSData>(block: { (resolve, reject) in
            print("start")
            dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), {
                print("wait")
                NSThread.sleepForTimeInterval(3.0)
                dispatch_sync(dispatch_get_main_queue(), {
                    print("wait complete")
                    let error = NSError(domain: "test error", code: 1, userInfo: nil)
                    reject(error)
                })

            })
        })

.then { (data) -> [String:String] in
      throw AWPromiseError.PromiseError("1 error")
}

func then<U>(f: (T throws -> U)) -> AWPromise<U> {
        return AWPromise<U>(block: { (resolve, reject) in
            self.f_error = reject /// 错误处理
            self.f_then = { (t:T) -> () in /// 下一步操作
                let u = f(t)
                resolve(u)
            }
        })
}

完整使用 Promise 对象进行网络请求的例子

func test_http_promise() {
    /// NSURLSession 的一些配置
    let queue = NSOperationQueue()
    let sessionConfiguration = NSURLSessionConfiguration.defaultSessionConfiguration()
    sessionConfiguration.timeoutIntervalForRequest = 3.0

    /// 1. 构造第一个请求
    AWPromise<NSData> (block:{ (resolve, reject) in
        let session = NSURLSession(configuration: sessionConfiguration, delegate: nil, delegateQueue: queue)
        let task = session.dataTaskWithURL(NSURL(string:"<https://www.zhihu.com>")!, completionHandler: { (data, response, error) in
            dispatch_sync(dispatch_get_main_queue(), {
                if let error = error {
                    reject(error)
                }
                else if let data = data {
                    resolve(data)
                }
            })
        })
        task.resume()
    })
    /// 2. 第一个请求返回结果
    .then { (data) -> () in
        print("First Request")
        let str = String(data: data, encoding: NSUTF8StringEncoding)
        print(str)
    }
    /// 3. 构造第二个请求
    .then { () -> AWPromise<NSData> in
        return AWPromise<NSData>(block: { (resolve, reject) in
            let session = NSURLSession(configuration: sessionConfiguration, delegate: nil, delegateQueue: queue)
            let task = session.dataTaskWithURL(NSURL(string:"<https://www.apple.com>")!, completionHandler: { (data, response, error) in
                dispatch_sync(dispatch_get_main_queue(), {
                    if let error = error {
                        reject(error)
                    }
                    else if let data = data {
                        resolve(data)
                    }
                })
            })
            task.resume()
        })
    }
    /// 4. 第二个请求返回结果，这里先转换到 String
    .then { (data) -> String in
        let str = String(data: data, encoding: NSUTF8StringEncoding)!
        return str
    }
    /// 5. 得到第二个请求的结果的字符串
    .then { (str) -> () in
        print("Second Request")
        print(str)
        print("All Completed")
    }
    /// 6. 用来处理错误
    .error { (error) in
        debugPrint(error)
    }
}

• 当第一个请求构造的时候，位于 1 的位置，我们创建一个 Promise 对象，并传入一个闭包，这个闭包是一个异步网络请求;

• 当这个异步请求完成的时候，调用这个 Promise 对象的 then 方法，这时位于 2, 他会得到一个 NSData 内容，是(dataTaskWithRequest)回调时的 NSData;

• 我们还想要做后续操作，所以可以继续使用 then, 由于下面一步并不需要来自前面的结果，所以 then 中的闭包并没有传递来参数，这时在 3 的位置，我们要构建第二个异步网络请求，访问 https://www.apple.com， 因为他又是一个异步请求，所以我们又要构造一个 Promise 对象用来封装这个过程。

• 第二个请求返回的时候来到 4, 得到了 NSData 数据，为了让代码看上去更清晰一点，我们在这里没有做更多的处理，只将他转换到 String ，然后将这后面工作划分到下面一步完成。

• 5 的时候得到了前面传递来的 String, 输出来，这样我们完成了全部流程了；

• 如果将第二个请求的地址改为 https://www.google.com, 由于一些奇怪的因素，第二个请求会发生错误， 这时会到 6，输出错误信息了。

这里实现的 Promise 对象全部代码

• AWPromise.swift

何去何从

• 封装异步/同步代码;

• 错误处理;

@gen.coroutine
def get(self):
    http_client = AsyncHTTPClient()
    response = yield http_client.fetch("<http://example.com>")
    self.write(response)

var asyncReadFile = async function (){
  var f1 = await readFile('/etc/fstab');
  var f2 = await readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};

参考

• Promise: 给我一个承诺，我还你一个承诺

• Promises in Swift

• 大白话讲解Promise（一）

• 如何处理 Swift 中的异步错误

• Swift 烧脑体操（五）- Monad

• 聊一聊单子（Monad）

• Functor、Applicative 和 Monad

• Swift 数组中 Map,FlatMap,Filter,Reduce的使用

• [为Swift编码引入map()和flatMap(), map those arrays](http://zyden.vicp.cc/map-those-arrays/?)

MING-ARTICLE-CONFIG

{
    "article_title": "探究 Promise 对象",
    "article_subtitle":"实现一个 Swift 下的 Promise ",
    "article_theme": "default",
    "article_link": "awpromise.html",
    "article_publish_date":"2016-05-09",
    "article_cover_photo":"<http://images.codingnext.com/photo-1457369804613-52c61a468e7d.jpeg>",
    "article_category":"code",
    "article_comments":1,
    "article_css": {}
}