相关疑难解决方法(0)

假设我有这个代码

function y(resolve, reject)
{
  console.log("Result");
  resolve();
}  

var promise = new Promise(y);

我想知道的是该函数是否y将异步执行.

我开始使用ES7功能async/await,它提供了处理异步任务的最佳方法,并使您的代码更清晰,更易读.

但是,它不会让您访问由异步函数创建的Promise,因此如果您在异步函数中执行了一些异步请求,则应该对其进行promisify,然后等待它然后返回结果.我是说这个:

async function doStuff() {
    //stuff...
    var value = await new Promise(function(resolve) {
        $.get('http://some/url/...', function(result) {
            // stuff...
            resolve(result);
        });
    });
    return value;
}

如果你能找到一个指向函数创建的Promise的指针,那么你的代码可能如下所示:

async function doStuff() {
    //stuff...
    var p = arguments.callee.promise;
    $.get('http://some/url/...', function(result) {
        // stuff...
        p.resolve(result);
    });
}

甚至:

async function doStuff() {
    //stuff...
    $.get('http://some/url/...', function(result) {
        // stuff...
        async.resolve(result);
    });
}

这样您就不需要直接访问Promises API,这使得您的代码完全专注于任务而不需要任何其他功能.

我想构建一个 Promise，但将解决方案推迟到以后。下面的代码创建了一个承诺，但它立即得到解决。我如何控制承诺何时被评估？

var p = new Promise((resolve, reject) => {
        resolve(1);
    })
    .then((p1) => {
        console.log(p1 + 1);
    });

更新：为了澄清，想要将承诺的声明与其执行分开的原因是then基于一些参数动态添加回调。

我创建了这个小助手来暴露resolve和reject在 Promise 的构造函数之外

export function createPromise() {
    let resolve,reject;
    let promise = new Promise((r,j) => {
        resolve = r;
        reject = j;
    });
    Object.assign(promise,{resolve,reject});
    return promise;
}

因为有时将整个脚本包装起来真的很尴尬

new Promise((resolve,reject) => { 
   // hundreds of lines of code, most which have nothing 
   // to do with this Promise but I need the Promise object 
   // at the top level somewhere so that I can expose it, 
   // but it won't be resolved until some deeply nested …

同步使用jQuery加载函数的最佳方法是什么？

我需要加载图像,但在加载图像之前无法执行下一行代码.

我可以循环一个变量,直到负载完成,但是想知道是否有更好的方法.

var img = jQuery('<img src="' + url + '"/>').load(function () {                 

            });  
  //Run code here once img load has comlpeted.                                              

如何实现扩展 Promise 的 Deferred 承诺？在需要典型 Promise 的情况下，为类型安全使用扩展 Promise 很重要。

实施后

export class Deferred<T> extends Promise<T> {                                   
  public _resolveSelf;
  public _rejectSelf;                                                           
  constructor() {
    super(
      (resolve, reject) =>
      {
        this._resolveSelf = resolve
        this._rejectSelf = reject
      }
    )
  }                                                                             
  public resolve(val:T) { this._resolveSelf(val) }
  public reject(reason:any) { this._rejectSelf(reason) }                        
}

抛出TypeError: _this is undefined。

在这个 Typescript playground 中，可以看到编译后的 javascript 很有趣。在第 15 行，在声明过程中_this已经分配了它的属性。