Javascript 过滤一次或多次

我有一个包含对象的数组：

objects = [a, b, c, ...]

对于给定的对象，我有许多函数返回true/false

functions = [f1, f2, f3, ...]

现在我想得到所有通过所有函数的对象。什么是最有效的

functions.forEach(function(f) {
       objects = objects.filter(f);
})

或

---

我不确定什么是最有效的，这取决于过滤功能有多重？它们是相同的吗？

在两种情况下，您都调用

对象。过滤器

对于每个函数，复杂性是相同的。如果对上一个过滤器的结果使用

filter

，而不是每次都对所有对象应用它，则可以稍微优化一下

for (f in functions){
    objects = objects.filter(functions[f])
}

---

如果可能，请按时间复杂度乘以函数返回True的概率（升序）对函数进行排序。

在这两种情况下，您都调用

对象。对于每个函数，过滤器的复杂度是相同的。如果对上一个过滤器的结果使用
filter
，而不是每次都对所有对象应用它，则可以稍微优化一下

for (f in functions){
    objects = objects.filter(functions[f])
}

如果可能，按时间复杂度乘以函数返回True的概率（升序）对函数进行排序。
我做了一个小测试：

  console.time("Creating objects");
  var objects1 = [];
  var objects2 = [];
  while (objects1.length < 20000) {
    var value = 1000 * Math.random();
    objects1.push({ value: value });
    objects2.push({ value: value });
  }
  console.timeEnd("Creating objects");

  console.time("Creating functions")
  var functions = [];
  while (functions.length < 1000) {
    var rnd_value = 1000 * Math.random();
    functions.push(function(o) {
        return o.value >= rnd_value;
    });
  }
  console.timeEnd("Creating functions")

  console.time("Functions outer")

  functions.forEach(function(f) {
    objects1 = objects1.filter(f);
  });

  console.timeEnd("Functions outer");

  console.time("Filter outer")

  objects2 = objects2.filter(function(o) {
    var ret = true;
    functions.forEach(function(f) {
      if (ret && !f(o)) ret = false;
    });
    return ret;
  });

  console.timeEnd("Filter outer");

console.time（“创建对象”）；
var objects1=[]；
var objects2=[]；
while（objects1.length<20000）{
var值=1000*Math.random（）；
objects1.push（{value:value}）；
objects2.push（{value:value}）；
}
console.timeEnd（“创建对象”）；
控制台时间（“创建函数”）
var函数=[]；
while（函数长度<1000）{
var rnd_value=1000*Math.random（）；
功能。推送（功能（o）{
返回o.value>=rnd_值；
});
}
console.timeEnd（“创建函数”）
控制台时间（“外部功能”）
函数。forEach（函数（f）{
objects1=objects1.filter（f）；
});
控制台。时间结束（“外部功能”）；
控制台时间（“外部过滤器”）
objects2=objects2.filter（函数（o）{
var-ret=真；
函数。forEach（函数（f）{
如果（ret&&！f（o））ret=false；
});
返回ret；
});
控制台。时间结束（“外部过滤器”）；

控制台中的结果是：
外部功能：3188.918ms
过滤器外部：454.249ms

因此，我假设数组上的过滤器函数在javascript中相当繁重。换句话说，我应该尽可能少地调用它。
我做了一个小测试：

  console.time("Creating objects");
  var objects1 = [];
  var objects2 = [];
  while (objects1.length < 20000) {
    var value = 1000 * Math.random();
    objects1.push({ value: value });
    objects2.push({ value: value });
  }
  console.timeEnd("Creating objects");

  console.time("Creating functions")
  var functions = [];
  while (functions.length < 1000) {
    var rnd_value = 1000 * Math.random();
    functions.push(function(o) {
        return o.value >= rnd_value;
    });
  }
  console.timeEnd("Creating functions")

  console.time("Functions outer")

  functions.forEach(function(f) {
    objects1 = objects1.filter(f);
  });

  console.timeEnd("Functions outer");

  console.time("Filter outer")

  objects2 = objects2.filter(function(o) {
    var ret = true;
    functions.forEach(function(f) {
      if (ret && !f(o)) ret = false;
    });
    return ret;
  });

  console.timeEnd("Filter outer");

console.time（“创建对象”）；
var objects1=[]；
var objects2=[]；
while（objects1.length<20000）{
var值=1000*Math.random（）；
objects1.push（{value:value}）；
objects2.push（{value:value}）；
}
console.timeEnd（“创建对象”）；
控制台时间（“创建函数”）
var函数=[]；
while（函数长度<1000）{
var rnd_value=1000*Math.random（）；
功能。推送（功能（o）{
返回o.value>=rnd_值；
});
}
console.timeEnd（“创建函数”）
控制台时间（“外部功能”）
函数。forEach（函数（f）{
objects1=objects1.filter（f）；
});
控制台。时间结束（“外部功能”）；
控制台时间（“外部过滤器”）
objects2=objects2.filter（函数（o）{
var-ret=真；
函数。forEach（函数（f）{
如果（ret&&！f（o））ret=false；
});
返回ret；
});
控制台。时间结束（“外部过滤器”）；

控制台中的结果是：
外部功能：3188.918ms
过滤器外部：454.249ms

因此，我假设数组上的过滤器函数在javascript中相当繁重。换句话说，我应该尽可能少地调用它。
复杂性应该是相同的。区别仅在于硬件架构和算法实现的交互。这取决于您未指定的平台。无论如何，唯一确定的方法是在你的平台上测量并选择更好的选项。谢谢，这是网站的客户端代码。复杂性应该是一样的。区别仅在于硬件架构和算法实现的交互。这取决于您未指定的平台。无论如何，唯一确定的方法是在您的平台上测量并选择更好的选项。谢谢，这是网站的客户端代码。正如我前面提到的，附加条件甚至可能会减慢速度，这取决于平台和算法的实现。但是，由于它是网页的客户端，如果过滤器在服务器端运行，而调用序列在客户端运行，那么这应该会提高性能。正如我前面提到的，附加条件甚至会降低速度，这取决于平台和算法的实现。但由于它是网页的客户端，如果过滤器在服务器端运行，在客户端调用序列，那么这应该会提高性能
filter
在每次调用时创建一个新数组。但是，除非这是代码中的瓶颈，否则只需执行最简单的操作。
filter
每次调用时都会创建一个新数组。但是，除非这是代码中的瓶颈，否则只需执行最简单的操作即可。