Question

我正在构建一个身份验证API，尝试针对不同的身份验证方法进行身份验证，直到成功（例如Spring Security）。

每个身份验证方法都会返回一个promise，如果身份验证成功就会完成，如果身份验证失败则会被拒绝。

要尝试对用户进行身份验证，我需要按顺序调用身份验证方法：

如果第一个身份验证方法成功，则对用户进行身份验证，然后我不希望调用其他身份验证方法。
如果第一种身份验证方法失败，我需要尝试第二种身份验证方法。等等......
如果没有一种身份验证方法成功，我需要拒绝身份验证，也许拒绝身份验证知道每次认证失败的原因。
如果验证成功，我需要取回一个值（验证对象）。

这个过程几乎是承诺库称为 .any （或 .some ），除了我不想执行每个承诺（因此尝试每种身份验证方法，这会导致不必要的工作量）。 我想在以前失败的情况下尝试下一种身份验证方法。

问题1：Promise / A +兼容库中是否有可用的功能？问题2：我一直在考虑以下方式（参见下面的代码），还有更好的方法吗？

// Defining some promise factories
var promiseFactory1 = {
    buildPromise: function() {
        return new Promise((resolve, reject) => {
            console.log('trying p1...');
            // resolve('p1 success');
            reject('p1 failure');
        })
    }
};

var promiseFactory2 = {
    buildPromise: function() {
        return new Promise((resolve, reject) => {
            console.log('trying p2...');
            // resolve('p2 success');
            reject('p2 failure');
        })
    }
};

var promiseFactory3 = {
    buildPromise: function() {
        return new Promise((resolve, reject) => {
            console.log('trying p3...');
            resolve('p3 success');
            // reject('p3 failure');
        })
    }
};

// Building the promise
let promisesFactory = [promiseFactory1, promiseFactory2, promiseFactory3];
let rejections = [];

var reducedPromise = promisesFactory.reduce(function(promise, nextFactory) {
    if (promise === null) return nextFactory.buildPromise();

    return promise.catch(err => {
        rejections.push(err);
        return nextFactory.buildPromise();
    });
}, null);

reducedPromise
    .catch(err => {
        rejections.push(err); // catching the last rejection
    })
    .then(success => {
        if(rejections.length == promisesFactory.length) {
            console.log(rejections);
            // TODO return Promise.reject(new SomeCustomError());
        } else {
            console.log(success);
            // TODO return Promise.resolve(success);
        }
    });

Answer 1

我相信你可以这样做（其中auth1，auth2和auth3是返回承诺的auth函数）：

auth1(/*args*/)
    .catch(failed => auth2(/*args*/))
    .catch(failed => auth3(/*args*/))
    .then(result => {
      console.log("Success:" + result);
      return result;
    })
    .catch(failed => {
      console.log("Failure:" + failed);
    });

由于我们没有then个回调，因此分辨率值会传播到最终then（就像拥有.then(result => result)）;但是我们从catch回调中返回新的承诺，触发下一个身份验证方法。

最后的then获得第一个后续auth方法的分辨率值;上面的最终catch只会获得 last 失败的auth方法（auth3）的拒绝原因。

Live on Babel's REPL

如果您需要所有失败的原因，您可以将它们保存在一个数组中：

let failures = [];
auth1(/*args*/)
    .catch(failed => {failures.push(failed); return auth2(/*args*/);})
    .catch(failed => {failures.push(failed); return auth3(/*args*/);})
    .then(result => {
      console.log("Success: " + result + " (failed: " + failures.join(", ") + ")");
      return result;
    })
    .catch(failed => {
      failures.push(failed);
      console.log("Failures: " + failures.join(", "));
    });

Live Copy

如果你的auth方法本身就在一个数组中，你可以循环执行上述操作：

let auths = [auth1.bind(null, /*args*/), auth2.bind(null, /*args*/), auth3.bind(null, /*args*/)];
return auths.reduce((p, auth) => p.catch(failed => auth()), Promise.reject())
    .then(result => {
      console.log("Success: " + result);
      return result;
    })
    .catch(failed => {
      console.log("Failed: " + failed);
    });

Live Copy

ES6承诺，只有先前的承诺被拒绝，同时保留拒绝理由，才能将承诺链接起来

1 个答案: