TypeScript 相当于 Dart `Completer`答案

【问题标题】：TypeScript equivalent to Dart `Completer`TypeScript 相当于 Dart `Completer`
【发布时间】：2016-04-12 22:48:28
【问题描述】：

在 Dart 中，我有一个 Completer，它返回一个 Future（承诺），并且 Future 可以在创建它的其他地方完成，例如

class SomeClass {
  final Completer<bool> initializationDone = new Completer<bool>();

  SomeClass() {
    _doSomeAsyncInitialization();
  }

  void _doSomeAsyncInitialization() {
    // some async initialization like a HTTP request
    fetchDataFromServer().then((data) {
      processData();
      initializationDone.complete(true);
    });
  }
}

main() {
  var some = new SomeClass();
  some.initializationDone.future.then((success) {
    // do something.
  });
}

我不想要这个实际问题的解决方案，这只是我想出的一个例子来演示如何在 Dart 中使用 Completer。什么相当于 TypeScript 中的 Dart Completer？

【问题讨论】：

那怎么样：stackoverflow.com/questions/27573365/…
@Etsitra 这个问题/答案没有提供太多信息。我试图弄清楚如何使用如上所示的 Promise，其中 Promise 在一个地方创建并在其他地方完成。
我不知道它在 TypeScript 中是如何工作的，但在纯 JavaScript 中，您可以将接受/拒绝函数存储在 Promise 回调中的某个位置。类似：function Completer() { this.promise = new Promise((c,e)=>{this.complete = c; this.completeError = e;}); }。这将创建一个带有 promise 字段和两个函数的完成器：complete 和 completeError。
感谢@lrn 这有助于找到实现。

标签： asynchronous typescript dart

【解决方案1】：

制作了这个对我有用的简单课程：

export class Completer<T> {
    public readonly promise: Promise<T>;
    public complete: (value: (PromiseLike<T> | T)) => void;
    private reject: (reason?: any) => void;

    public constructor() {
        this.promise = new Promise<T>((resolve, reject) => {
            this.complete = resolve;
            this.reject = reject;
        })
    }
}

const prom = new Completer<bool>();

prom.complete(true);

【讨论】：

【解决方案2】：

这看起来像是在 TypeScript https://github.com/angular/angular/blob/b0009f03d510370d9782cf76197f95bb40d16c6a/modules/angular2/src/facade/promise.ts 中实现这样的 Completer

export {Promise};

export interface PromiseCompleter<R> {
  promise: Promise<R>;
  resolve: (value?: R | PromiseLike<R>) => void;
  reject: (error?: any, stackTrace?: string) => void;
}

export class PromiseWrapper {
  static resolve<T>(obj: T): Promise<T> { return Promise.resolve(obj); }

  static reject(obj: any, _): Promise<any> { return Promise.reject(obj); }

  // Note: We can't rename this method into `catch`, as this is not a valid
  // method name in Dart.
  static catchError<T>(promise: Promise<T>,
                       onError: (error: any) => T | PromiseLike<T>): Promise<T> {
    return promise.catch(onError);
  }

  static all(promises: any[]): Promise<any> {
    if (promises.length == 0) return Promise.resolve([]);
    return Promise.all(promises);
  }

  static then<T, U>(promise: Promise<T>, success: (value: T) => U | PromiseLike<U>,
                    rejection?: (error: any, stack?: any) => U | PromiseLike<U>): Promise<U> {
    return promise.then(success, rejection);
  }

  static wrap<T>(computation: () => T): Promise<T> {
    return new Promise((res, rej) => {
      try {
        res(computation());
      } catch (e) {
        rej(e);
      }
    });
  }

  static scheduleMicrotask(computation: () => any): void {
    PromiseWrapper.then(PromiseWrapper.resolve(null), computation, (_) => {});
  }

  static isPromise(obj: any): boolean { return obj instanceof Promise; }

  static completer(): PromiseCompleter<any> {
    var resolve;
    var reject;

    var p = new Promise(function(res, rej) {
      resolve = res;
      reject = rej;
    });

    return {promise: p, resolve: resolve, reject: reject};
  }
}

【讨论】：