Javascript 使用附加承诺

我想创建一个函数，它返回一个promise，如果有东西在其中抛出错误，它将返回promise-reject

function promiseFunc(options) {
  return new Promise(() => {
    return options;
  });
}

function myfunc(options) {
  return new Promise(() => {
    if (!options) throw new Error("missing options");

    return promiseFunc(options).then((result) => {
      if (result.throwerr) throw new Error("thrown on purpose");

      return result.value;
    });
  });
};

我的测试如下：

const myfunc = require("./myfunc");

describe('myfunc', () => {
  it('should fail without options', () => {
    return myfunc()
      .then((result) => { throw new Error(result) }, (err) => {
        console.log("test #1 result:", err.message === "missing options");
      });
  });

  it('should fail on options.throwerr', () => {
    return myfunc({throwerr: true})
      .then((result) => {}, (err) => {
        console.log("test #2 result:", err.message === "thrown on purpose");
      });
  });

  it('should return options.value', () => {
    return myfunc({value: "some result", throwerr: false})
      .then((result) => {
        console.log("test #3 result:", result === "some result");
      }, (err) => {});
  });
});

第一次测试通过，但第二次和第三次失败

Log#2甚至不运行，所以我假设“故意抛出”会弄糟一些东西，因此我创建了test#3，在这里我不抛出任何东西，但它仍然失败。 我错过了什么

解决方案：

function promiseFunc(options) {
  return new Promise(resolve => {
    return resolve(options);
  });
}

function myfunc(options) {
  return new Promise((resolve, reject) => {
    if (!options) throw new Error("missing options");

    return promiseFunc(options).then(result => {
      if (result.throwerr) throw new Error("thrown on purpose");

      return resolve(result.value);
    }).catch(err => {
      return reject(err);
    });
  });
};

---

我想创建一个函数，它返回一个promise，如果有东西在其中抛出错误，它将返回promise-reject

function promiseFunc(options) {
  return new Promise(() => {
    return options;
  });
}

function myfunc(options) {
  return new Promise(() => {
    if (!options) throw new Error("missing options");

    return promiseFunc(options).then((result) => {
      if (result.throwerr) throw new Error("thrown on purpose");

      return result.value;
    });
  });
};

这样就可以了

var q = require('q'); // In recent versions of node q is available by default and this line is not required

function iReturnAPromise(num) {

    var def = q.defer();

    if (typeof num=== 'number') {

        try {
            var value = 100 / num;
            def.resolve(value);
        } catch(e) {
            def.reject("oops a division error - maybe you divided by zero");
        }
    } else {
        def.reject("o no its not a number");
    }
    return def.promise;
}

PS此功能是徒手编写的，尚未经过测试-但这将起作用。显然，试捕应该少用

---

PS我更喜欢promise的q库实现，而不是默认的节点promise库-它们采用非常不同的方法。免除所有包装

您忘记传递带有resolve和reject参数的函数，因此您的承诺根本不起作用

function promiseFunc(options) {
  return new Promise(resolve => { // resolve function
    resolve(options)
  })
}

module.exports = function myfunc(options) {
  return new Promise((resolve, reject) => { // since you may either resolve your promise or reject it, you need two params
    if (!options) {
      return reject(new Error("missing options"))
    }

    return promiseFunc(options).then(result => {
      if (result.throwerr) {
        return reject(new Error("thrown on purpose"))
      }
      resolve(result.value)
    })
  })
}

。。。和测试（摩卡）

const assert=require（'assert'），
myfunc=需要（“./myfunc”）
描述（'myfunc'，（）=>{
它（'should fail without options'，done=>{//注意回调，承诺总是异步的
myfunc（）
.catch（错误=>{
断言（err.message==“缺少选项”）
完成（）//{
myfunc（{throwerr:true}）
.catch（错误=>{
断言（err.message==“故意抛出”）
完成（）
})
})
它（'应该返回options.value'，done=>{
返回myfunc（{value:“某些结果”，throwerr:false}）
。然后（结果=>{
断言（结果==“某些结果”）
完成（）
})
})
})

使用您想要的promise库

function iReturnAPromise(num) {


return new Promise(function(resolve, reject) {


    if (typeof num === 'number') {

        try {
            var value = 100 / num;
            resolve(value);
        } catch (e) {
            reject("oops a division error - maybe you divided by zero");
        }
    } else {
        reject("o no its not a number");
    }

})

}

iReturnAPromise(7).then(
    function(response) {console.log("success", response)},
    function(response) {console.log("failure", response)}
);

// Unexpectedly this is not an error in node 5.6 because div by 0 is not an error operation anymore!
iReturnAPromise(0).then(
    function(response) {console.log("success", response)},
    function(response) {console.log("failure", response)}
);

iReturnAPromise("fred").then(
    function(response) {console.log("success", response)},
    function(response) {console.log("failure", response)}
);

---

您可以看到为什么我更喜欢q语法：）

是否可以使用本机Promise？是的，非常可能使用相同的逻辑和不同的语法！我已经有一段时间没有使用本机Promise库了，我更喜欢q，因此无法在不查找它的情况下对其进行编码，我将把它留给您：）谢谢！我想排除任何外部库，所以我想我必须继续对其进行调试：）q不是t node最新版本中的外部库-其内置且默认情况下不需要它-取决于您使用的node版本。哦，我不知道。我目前使用的是5.6，但现在是更新它的时候了。再次感谢您！是的，它可以工作，但是如果在myfunc返回resolve/reje之前出现错误怎么办ct？顺便说一句，mocha doc说，如果您返回承诺，您不需要完成回调。在myfunc中，第一次抛出是可以的，只有嵌套的抛出会扰乱测试。不知道mocha-谢谢。关于承诺-它们会自动捕获承诺体中所有未捕获的错误。但是，最好使用拒绝回调，而不是抛出n错误。将其视为一个控制结构，在该结构中，您可以执行两个操作中的一个-履行承诺，或拒绝承诺，如果出现错误（例如选项未定义）。感谢您指出缺少的承诺参数。经过轻微修改，我成功地使其工作。避免错误！