标签: es6-promise

据我所知,promise是可以解决()或拒绝()但我很惊讶发现在调用解析或拒绝后,promise中的代码继续执行.

我认为解决或拒绝是退出或返回的异步友好版本,这将停止所有立即执行功能.

有人可以解释为什么以下示例有时会在解析调用后显示console.log的想法:

var call = function() {
    return new Promise(function(resolve, reject) {
        resolve();
        console.log("Doing more stuff, should not be visible after a resolve!");
    });
};

call().then(function() {
    console.log("resolved");
});

jsbin

我试图了解如何调试基于promises的异步代码.By Promises我的意思是基于ECMAScript 6的承诺,通过调试我的意思是使用内置的chrome或firefox调试器.

我遇到的问题是 - 当发生错误时,无论我如何拒绝它,我都无法获得堆栈跟踪.

我试过这些:

console.log(new Error('Error occured'));
throw new Error('Throwing an Error');
return new Error('Error returned by the onRejected function');
reject(new Error('Pass Error to the reject function'));

但是这些都不会返回代码中的实际错误或堆栈跟踪.

所以我的问题是 - 如何正确调试javascript Promises？

我有一些代码在一个列表中进行迭代,该列表从数据库中查询并为该列表中的每个元素发出HTTP请求.该列表有时可能是一个相当大的数字(成千上万),我想确保我没有遇到数千个并发HTTP请求的Web服务器.

此代码的缩写版本目前看起来像这样......

function getCounts() {
  return users.map(user => {
    return new Promise(resolve => {
      remoteServer.getCount(user) // makes an HTTP request
      .then(() => {
        /* snip */
        resolve();
      });
    });
  });
}

Promise.all(getCounts()).then(() => { /* snip */});

此代码在Node 4.3.2上运行.重申Promise.all一下,可以进行管理,以便在任何给定时间只有一定数量的Promise正在进行中？

在使用rxjs的Angular 2中,我试图将Promise转换为Observable.由于许多在线指南的显示我用fromPromise的Observable.哪个抛出错误:

Property 'fromPromise' does not exist on type 'typeof Observable'.

Observable导入如下:

import { Observable } from "rxjs/Observable";

尝试fromPromise像其他运算符一样导入会导致错误:

import 'rxjs/add/operator/fromPromise';

即使我压制打字稿错误,它仍然会导致错误:

(<any>Observable).fromPromise

错误:

Uncaught (in promise): TypeError: __WEBPACK_IMPORTED_MODULE_3_rxjs_Observable__.Observable.fromPromise is not a function

rxjs repo 在这里报告了一些类似的问题,但也没有解决方案.

使用ES6承诺,如何在不定义解析逻辑的情况下创建承诺？这是一个基本的例子(一些TypeScript):

var promises = {};
function waitFor(key: string): Promise<any> {
  if (key in promises) {
    return promises[key];
  }
  var promise = new Promise(resolve => {
    // But I don't want to try resolving anything here :(
  });

  promises[key] = promise;
  return promise;
}

function resolveWith(key: string, value: any): void {
  promises[key].resolve(value); // Not valid :(
}

使用其他promise库可以轻松完成.以JQuery为例:

var deferreds = {};
function waitFor(key: string): Promise<any> {
  if (key in promises) {
    return deferreds[key].promise();
  }
  var def = $.Deferred();    
  deferreds[key] = …

我有以下功能,试图使用Promises.

var getDefinitions = function() {
    return new Promise(function(resolve) {
        resolve(ContactManager.request("definition:entities"));
    });
}

var definitions = getDefinitions()

definitions 正在回归:

Promise {
    [[PromiseStatus]]: "resolved",
    [[PromiseValue]]: child
}

我想获得PromiseValue的价值,但要求

var value = definitions.PromiseValue; // undefined

给了我一个不确定的结果.

我的问题是双括号是什么PromiseValue意思,我该如何检索它的值[[ ]].

我有一个HTTP API,它在成功和失败时返回JSON数据.

示例失败将如下所示:

~ ? http get http://localhost:5000/api/isbn/2266202022 
HTTP/1.1 400 BAD REQUEST
Content-Length: 171
Content-Type: application/json
Server: TornadoServer/4.0

{
    "message": "There was an issue with at least some of the supplied values.", 
    "payload": {
        "isbn": "Could not find match for ISBN."
    }, 
    "type": "validation"
}

我想在JavaScript代码中实现的是这样的:

fetch(url)
  .then((resp) => {
     if (resp.status >= 200 && resp.status < 300) {
       return resp.json();
     } else {
       // This does not work, since the Promise returned by `json()` is never fulfilled
       return Promise.reject(resp.json()); …

作为一种组织模式,ES6类可以为异步代码提供什么.下面是ES7 async/await的示例,ES6类可以在ES7中使用异步方法或构造函数吗？

我可不可以做:

class Foo {
    async constructor() {
        let res = await getHTML();
        this.res = res
    }
}

而且,如果不是,构造函数应如何工作呢？

class Foo {
    constructor() {
        getHTML().then( function (res) {
            this.res = res
        }
    }
}

如果这些模式都不起作用,那么ES6中的构造函数(以及类)是否class支持对对象状态进行操作的任何形式的异步性？或者,它们仅用于纯粹的同步代码库吗？上面的例子在构造函数中,但它们不需要是......将问题再推下一级......

class Foo {
    myMethod () {
      /* Can I do anything async here */
    }
}

或者,用吸气剂......

class Foo {
    get myProp() {
        /* Is there any case that this is usefully asynchronous */
    }
}

我能想到的唯一例子是在同一个方法/构造函数/ getter中并行运行某些东西,但是要在结束之前解决整个问题.我只是感到困惑,因为它似乎完全异步库的所有推动,这只是混淆事情.除了教科书示例,我找不到一个他们有用的应用程序.

关于这两个很重要的来源:NZakas - 承诺链中的承诺和MDN承诺,我想问以下问题:

每次我们从promise履行处理程序返回一个值时,该值是如何传递给从同一个处理程序返回的新promise？

例如,

let p1 = new Promise(function(resolve, reject) {
    resolve(42);
});

let p2 = new Promise(function(resolve, reject) {
    resolve(43);
});

let p3 = p1.then(function(value) {
    // first fulfillment handler
    console.log(value);     // 42
    return p2;
});

p3.then(function(value) {
    // second fulfillment handler
    console.log(value);     // 43
});

在这个例子中,p2是一个承诺.p3也是源于p1履行处理者的承诺.但是p2 !== p3.相反,p2不知何故神奇地解决43(如何？),然后将该值传递给p3履行处理程序.即使是这里的句子也令人困惑.

你能否向我解释一下究竟发生了什么？我对这个概念感到困惑.

我有一个场景,我将返回一个承诺.承诺基本上给出了ajax请求的响应.

在拒绝承诺时,它显示错误对话框,表明存在服务器错误.

我想要做的是当响应代码是401时,我既不想解决承诺也不想拒绝它(因为它显示错误对话框).我想简单地重定向到登录页面.

我的代码看起来像这样

function makeRequest(ur,params) {

    return new Promise(function(resolve,reject) {

        fetch(url,params)
        .then((response) => {

            let status = response.status;

            if (status >= 200 && status < 300) {
                response.json().then((data) => {
                    resolve(data);
                })
            }
            else {
                if(status === 401) {
                    redirectToLoginPage();
                }
                else {
                    response.json().then((error) => {

                        if (!error.message) {
                            error.message = constants.SERVER_ERROR;
                        }
                        reject({status,error});
                    })    
                }
            }

        })
    });
}

正如您所看到的状态是401,我正在重定向到登录页面.承诺既未得到解决也未被拒绝.

这段代码好吗？或者有更好的方法来实现这一目标.

谢谢.