相关疑难解决方法(0)

我已经阅读了几篇关于这个主题的文章,但我仍然不清楚是否Promise.reject与抛出错误之间存在差异.例如,

使用Promise.reject

return asyncIsPermitted()
    .then(function(result) {
        if (result === true) {
            return true;
        }
        else {
            return Promise.reject(new PermissionDenied());
        }
    });

用投掷

return asyncIsPermitted()
    .then(function(result) {
        if (result === true) {
            return true;
        }
        else {
            throw new PermissionDenied();
        }
    });

我的偏好是throw仅仅因为它更短而使用,但是想知道一个是否有任何优势.

处理此方案的最佳方法是什么.我处于受控环境中,我不想崩溃.

var Promise = require('bluebird');

function getPromise(){
    return new Promise(function(done, reject){
        setTimeout(function(){
                throw new Error("AJAJAJA");
        }, 500);
    });
}

var p = getPromise();
    p.then(function(){
        console.log("Yay");
    }).error(function(e){
        console.log("Rejected",e);
    }).catch(Error, function(e){
        console.log("Error",e);
    }).catch(function(e){
        console.log("Unknown", e);
    });

从setTimeout中抛出时,我们总是得到:

$ node bluebird.js

c:\blp\rplus\bbcode\scratchboard\bluebird.js:6
                throw new Error("AJAJAJA");
                      ^
Error: AJAJAJA
    at null._onTimeout (c:\blp\rplus\bbcode\scratchboard\bluebird.js:6:23)
    at Timer.listOnTimeout [as ontimeout] (timers.js:110:15)

如果抛出发生在setTimeout之前,那么bluebirds catch会把它拿起来:

var Promise = require('bluebird');

function getPromise(){

    return new Promise(function(done, reject){
        throw new Error("Oh no!");
        setTimeout(function(){
            console.log("hihihihi")
        }, 500);
    });
}

var p = getPromise();
    p.then(function(){ …

为什么try ... catch不能用于下面的示例代码？

const http2 = require("http2")
const url = require("url")


function sendRequest() {
    return new Promise((resolve, reject) => {

        var r = http2.request({
            "host": "www.google.com",
            "method": "GET",
            "path": "/"
        }, (resp) => {
            var data = []
            resp.on("data", (chunk) => {
                throw ("Error")
            })
            resp.on("end", () => {
                console.log("ended")
                resolve("finished")
            })
            resp.on("error", (e) => {
                console.log("error")
                reject(e)
            })
        })
        r.end()
    })
}

async function wrapper(){
    try {
        console.log("Sending request")
        await sendRequest()
        console.log("Finished sending Request")
    }catch(e){
        console.log("error!") // Supposed to …

我什么时候应该使用哪个？以下是相同的吗？

新的Promise()示例:

function multiRejectExample(){ 
  return new Promise(function (resolve, reject){
    if(statement){
      console.log('statement 1');
      reject(throw new Error('error'));
    }
    if(statement){
     console.log('statement 2');
     reject(throw new Error('error')); 
   }
  });
}

Promise.try()示例:

function tryExample(){
  return Promise.try(function(){
    if(statement){
      console.log('statement 1');
      throw new Error('error');
    }
    if(statement){
     console.log('statement 2');
     throw new Error('error'); 
   }
  });
}

在 Angular 的 github 问题、谷歌或这里在 stackoverflow 上搜索“Uncaught (in promise)”会产生很多非常具体的结果，但我的问题更广泛一些（而且由于结果的扩散，我不知道这是否是重复的）

前提：在我的代码中的某个地方，我有一个未捕获的承诺拒绝（Angular 4.4.4）

案例：

案例 1：简单拒绝

在我的组件中：

ngOnInit() {
    Promise.reject("foo");
}

在控制台中产生这个（太好了，我可以看到它来自哪里）：

ERROR Error: Uncaught (in promise): foo
    at resolvePromise (zone.js:824)
    at Function.ZoneAwarePromise.reject (zone.js:903)
    at MyComponent.webpackJsonp.../../../../../src/app/component/my.component.ts.MyComponent.ngOnInit (my.component.ts:nn)

案例二：new Promise，抛出错误

在我的组件中：

ngOnInit() {
  new Promise((resolve, reject) => {
    throw new Error("foo");
  }).then(() => {
    console.log("ain't gonna happen");
  });
}

在控制台中产生这个（更好的是，当场给出位置）：

ERROR Error: Uncaught (in promise): Error: foo
Error: foo
    at my.component.ts:nn
    at new ZoneAwarePromise (zone.js:890)
    at MyComponent.webpackJsonp.../../../../../src/app/component/my.component.ts.LMyComponent.ngOnInit (my.component.ts:nn)

这也适用于链接，例如以下在控制台中或多或少地给出相同的堆栈跟踪。

ngOnInit() {


  const promise3 …

我有一个包含AJAX请求的Bluebird承诺,需要在请求失败时拒绝承诺.我想提供为什么请求失败的原因,主要是从状态代码中提取到可能附加的任何catch块.为了实现这一点,我有UnauthorizedError和NotFoundError类似的类,都扩展Error到与Bluebird的模式匹配catch.

我不确定的部分是我应该throw还是调用拒绝处理程序.我的代码看起来像:

class Request {
  // other methods

  send(method, url, args, body) {
    return new Promise((res, rej) => {
      let xhr = new XMLHttpRequest();
      xhr.open(method, url);

      xhr.onload = () => {
        res(JSON.parse(xhr.responseText));
      };

      xhr.onerror = () => {
        let status = xhr.status;
        switch (status) {
          case 401:
            // Should I use throw:
            throw new UnauthorizedError(url);
            // or
            rej(new UnauthorizedError(url));
        }
      };

      xhr.send();
    });
  }
}

我认为Promise.resolve并且new Promise(resolve)可以互换。

考虑一下：

一种。

new RSVP.Promise(function (resolve, reject) {
    resolve();
}).then(function () {
    return new RSVP.Promise(function (resolve) {
        resolve("HI")
    });
}).then(function (result) {
    console.log(result);
});

B．

new RSVP.Promise(function (resolve, reject) {
    resolve();
}).then(function () {
    return RSVP.resolve("HI");
}).then(function (result) {
    console.log(result);
});

如我所料，两个都打印“ HI”。

因此，我认为如果我不需要“拒绝”任何东西。我可以简单写RSVP.resolve();。

但是，请考虑以下示例：

new RSVP.Promise(function (resolve, reject) {
    resolve();
}).then(function () {
    return new RSVP.Promise(function (resolve, reject) {
        setTimeout(function () {
            resolve("HI")
        }, 3000);
    });
}).then(function (result) {
    console.log(result);
});

如何使用 …

我一直试图理解为什么下面的代码没有抓住它throw.如果async从new Promise(async (resolve, ...部件中删除关键字,那么它可以正常工作,因此它与Promise执行程序是异步函数的事实有关.

(async function() {

  try {
    await fn();
  } catch(e) {
    console.log("CAUGHT fn error -->",e)
  }

})();

function fn() {

  return new Promise(async (resolve, reject) => {
    // ...
    throw new Error("<<fn error>>");
    // ...
  });

}

这里的答案,这里和这里重复一遍"如果你在任何其他异步回调中,你必须使用reject",但是"异步"它们并不是指async函数,所以我认为它们的解释不适用于此(如果他们这样做,我不明白如何).

如果不是throw我们使用reject,上面的代码工作正常.从根本上说,我想明白为什么throw不在这里工作.谢谢!