Question

LIVE DEMO

给出以下功能：

function isGood(number) {
  var defer = $q.defer();

  $timeout(function() {
    if (<some condition on number>) {
      defer.resolve();
    } else {
      defer.reject();
    }
  }, 100);

  return defer.promise;
}

和一组数字（例如[3, 9, 17, 26, 89]），我想找到第一个＆＃34;好＆＃34;数。我希望能够做到这一点：

var arr = [3, 9, 17, 26, 89];

findGoodNumber(arr).then(function(goodNumber) {
  console.log('Good number found: ' + goodNumber);
}, function() {
  console.log('No good numbers found');
});

这是一个可能的递归版本来实现这个：DEMO

function findGoodNumber(numbers) {
  var defer = $q.defer();

  if (numbers.length === 0) {
    defer.reject();
  } else {
    var num = numbers.shift();

    isGood(num).then(function() {
      defer.resolve(num);
    }, function() {
      findGoodNumber(numbers).then(defer.resolve, defer.reject)
    });
  }

  return defer.promise;
}

我想知道是否有更好的（可能是非递归的）方式？

Answer 1

我想知道是否有更好的方法？

是。避免使用deferred antipattern！

function isGood(number) {
  return $timeout(function() {
    if (<some condition on number>) {
      return number; // Resolve with the number, simplifies code below
    } else {
      throw new Error("…");
    }
  }, 100);
}
function findGoodNumber(numbers) {
  if (numbers.length === 0) {
    return $q.reject();
  } else {
    return isGood(numbers.shift()).catch(function() {
      return findGoodNumber(numbers);
    });
  }
}

可能是非递归的？

你可以制定一个链接大量then次调用的循环，但是递归在这里绝对没问题。如果你真的想要循环，它可能看起来像这样：

function findGoodNumber(numbers) {
  return numbers.reduce(function(previousFinds, num) {
    return previousFinds.catch(function() {
      return isGood(num);
    });
  }, $q.reject());
}

然而这效率较低，因为它始终关注所有numbers。 “递归”版本将懒惰地评估它，并且如果当前数字不好则仅进行另一次迭代。

也许更快？

您可以并行触发所有isGood项检查，并等待第一次完成检查。根据{{1}}实际执行的内容以及可并行化的程度，这可能会“更好”。但是，它可能会做很多不必要的工作;您可能希望使用支持取消的承诺库。

使用Bluebird库的示例，该库具有专用于此任务的any helper function：

isGood

Answer 2

这是一种具有不同递归形式的替代解决方案：

function firstGood(arr){
    var i = 0;
    return $q.when().then(function consume(){
        if(i >= arr.length) return $q.reject(Error("No Number Found"));
        return isGood(arr[i++]).catch(consume);
    });
}

它非常类似于Bergi所拥有的，它是关于如果没有像某些库（Bluebird和最近的When）那样实现Promise.reduce而获得的最佳效果。

Answer 3

这是我的版本，只需使用array.map函数

Demo

angular.module('MyApp', []).run(function($q, $timeout) {
  var arr = [3, 9, 17, 26, 89];

  findGoodNumber(arr).then(function(goodNumber) {
    console.log('Good number found: ' + goodNumber);
  }, function() {
    console.log('No good numbers found');
  });

  function findGoodNumber(numbers) {
    var defer = $q.defer();

    numbers.forEach(function(num){      
      isGood(num).then(function(){
        defer.resolve(num);
      });

    });

    return defer.promise;
  }

  function isGood(number) {
    var defer = $q.defer();

    $timeout(function() {
      if (number % 2 === 0) {
        defer.resolve();
      } else {
        defer.reject();
      }
    }, 1000);

    return defer.promise;
  }
});

Answer 4

承诺从来没有被用作布尔，但这实际上是isGood()正在做的事情。在这里，我们不仅仅意味着使用布尔值来解析/拒绝承诺。我们的意思是承诺的状态传达其状态：

pending ==尚未知晓
已解决== true
被拒绝== false

有些人可能会认为这是承诺滥用，但尝试以这种方式利用承诺会很有趣。

可以说，有关承诺的主要问题是布尔值：

'true'的承诺表示将采用成功路径，'false'的承诺表示将采用失败路径
Promise库自然不允许所有必要的布尔代数 - 例如。 NOT，AND，OR，XOR

在更好地探索和记录本主题之前，需要想象力来克服/利用这些功能。

让我们尝试解决问题（使用jQuery - 我知道它更好）。

首先让我们写一个更明确的isGood()版本：

/*
 * A function that determines whether a number is an integer or not
 * and returns a resolved/rejected promise accordingly.
 * In both cases, the promise is resolved/rejected with the original number.
 */ 
function isGood(number) {
    return $.Deferred(function(dfrd) {
        if(parseInt(number, 10) == number) {
            setTimeout(function() { dfrd.resolve(number); }, 100);//"true"
        } else {
            setTimeout(function() { dfrd.reject(number); }, 100);//"false"
        }
    }).promise();
}

我们需要一种“非”方法 - 交换'已解决'和'拒绝'的方法。 jQuery promises没有原生逆变器，所以这是一个完成这项工作的功能。

/* 
 * A function that creates and returns a new promise 
 * whose resolved/rejected state is the inverse of the original promise,
 * and which conveys the original promise's value.
 */ 
function invertPromise(p) {
    return $.Deferred(function(dfrd) {
        p.then(dfrd.reject, dfrd.resolve);
    });
}

现在，该问题的版本为findGoodNumber()，但此处利用了重写的isGood()和invertPromise()实用程序。

/*
 * A function that accepts an array of numbers, scans them,
 * and returns a resolved promise for the first "good" number,
 * or a rejected promise if no "good" numbers are present.
 */ 
function findGoodNumber(numbers) {
    if(numbers.length === 0) {
        return $.Deferred.reject().promise();
    } else {
        return invertPromise(numbers.reduce(function(p, num) {
            return p.then(function() {
                return invertPromise(isGood(num));
            });
        }, $.when()));
    }
}

最后，相同的调用例程（数据略有不同）：

var arr = [3.1, 9.6, 17.0, 26.9, 89];
findGoodNumber(arr).then(function(goodNumber) {
    console.log('Good number found: ' + goodNumber);
}, function() {
    console.log('No good numbers found');
});

<强> DEMO

将代码转换回Angular / $ q应该非常简单。

<强>解释

else的{{1}}条款可能不太明显。它的核心是findGoodNumber()，它构建了一个numbers.reduce(...)链 - 实际上是.then()数组的异步扫描。这是一种熟悉的异步模式。

在没有两次反转的情况下，阵列将被扫描，直到找到第一个坏号，结果拒绝将采用失败路径（跳过剩余的扫描并继续进行失败处理程序）。

但是，我们希望找到第一个好号来采取“失败”路径 - 因此需要：

内部反转：将报告的“true”转换为“false” - 强制跳过剩余的扫描
外部反转：恢复原始的布尔意义 - “true”最终为“true”，“false”最终为“false”。

您可能需要弄乱demo以更好地了解正在发生的事情。

<强>结论

是的，没有递归就可以解决问题。

这个解决方案既不是最简单也不是最有效，但它有希望证明promises'状态代表布尔值和实现异步布尔代数的潜力。

替代解决方案

numbers可以通过执行“OR扫描”而不需要反转来编写，如下所示：

findGoodNumber()

这是jQuery等同于Bergi的解决方案。

<强> DEMO

Javascript：如何使用promises迭代数组？

4 个答案:

替代解决方案