Asynchronous 相当于省道`完成符的打字脚本`

在Dart中，我有一个

完成符

，它返回一个

未来

（Promise），并且

未来

可以在创建它的其他地方完成，比如

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.
  });
}

class-SomeClass{
final Completer initializationDone=new Completer（）；
SomeClass（）{
_doSomeAsyncInitialization（）；
}
void _doSomeAsyncInitialization（）{
//一些异步初始化，比如HTTP请求
fetchDataFromServer（）。然后（（数据）{
processData（）；
初始化完成。完成（true）；
});
}
}
main（）{
var some=new SomeClass（）；
some.initializationDone.future.then（（成功）{
//做点什么。
});
}

我不想为这个实际问题找到解决方案，这只是我提出的一个示例，用于演示如何在Dart中使用

补全符。
什么是TypeScript中的Dart
完成器的等价物？
这看起来像是TypeScript中这样的
完成器的实现

export{Promise}；
导出接口承诺完成器{
承诺：承诺；
决议：（价值？：R |承诺）=>无效；
拒绝：（错误？：任何，stackTrace？：字符串）=>无效；
}
导出类承诺包装器{
静态解析（obj:T）：承诺{返回承诺.解析（obj）；}
静态拒绝（obj:any，u）：承诺{返回承诺.拒绝（obj）；}
//注意：我们无法将此方法重命名为“catch”，因为这不是有效的
//Dart中的方法名称。
静态捕获错误（承诺：承诺，
onError:（错误：any）=>T | PromiseLike）：承诺{
返回承诺。捕获（onError）；
}
静态所有（承诺：任何[]）：承诺{
如果（promises.length==0）返回Promise.resolve（[]）；
返回承诺。全部（承诺）；
}
然后静态（承诺：承诺，成功：（值：T）=>U |承诺，
拒绝？：（错误：any，stack？：any）=>U | PromiseLike）：承诺{
回报承诺。然后（成功，拒绝）；
}
静态包装（计算：（）=>T）：承诺{
返回新承诺（（res，rej）=>{
试一试{
res（计算（））；
}捕获（e）{
rej（e）；
}
});
}
静态scheduleMicrotask（计算：（）=>any）：无效{
然后（PromiseWrapper.resolve（null），计算，（）=>{}）；
}
静态isPromise（obj:any）：布尔{return obj instanceof Promise；}
静态完成符（）：PromiseCompleter{
var解析；
var拒绝；
var p=新承诺（功能（res，rej）{
分辨率=分辨率；
拒绝=rej；
});
返回{promise:p，resolve:resolve，reject:reject}；
}
}
为我制作了一个简单的课程：

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);

导出类完成符{
公共只读承诺：承诺；
公共完成：（价值：（承诺式| T））=>无效；
私人拒绝：（原因？：任何）=>无效；
公共构造函数（）{
this.promise=新承诺（（解决、拒绝）=>{
这个。完成=决心；
这个。拒绝=拒绝；
})
}
}
const prom=新的完成符（）；
prom.complete（正确）；
那怎么办：@Etsitra这个问题/答案提供的信息不多。我试图找出如何使用如上所示的承诺，承诺在一个地方创建，在其他地方完成。我不知道它在TypeScript中如何工作，但在普通JavaScript中，您可以将接受/拒绝函数存储在承诺回调的某个地方。类似于：
function Completer（）{this.promise=newpromise（（c，e）=>{this.complete=c；this.completeError=e；}）；}
。这将创建一个带有
promise
字段和两个函数的完成器：
complete
和
completeError
。感谢@lrn这有助于找到实现。
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);