Javascript 仅在所有数组中找到返回值

这个问题很简单，但我不知道怎么解决

我有几个数组，但我只希望所有数组都有相同的值

---

我正在使用javascript。

尝试使用在每个数组中查找值

---

我从来不知道IE不支持indexOf，但这里有一个来自的快速修复方法。

尝试使用查找每个数组中的值

---

我从来不知道IE不支持indexOf，但这里有一个来自的快速修复方法。

我认为这应该可以

var arr1 = [1,2,3,4]
  , arr2 = [2,3,4,5]
  , arr3 = [3,4,5,6]
  , arrs = [arr1, arr2, arr3];

var all = arr1.concat(arr2.concat(arr3)).sort()
  , red1 = all.filter(
        function(val, i, arr) {
          return i === arr.lastIndexOf(val)-1;
        })
  , red2 = red1.filter(
        function(val, i, arr) {
           var shared = true;
           arrs.forEach(
               function(arr, i, src) {
                 if (arr.indexOf(val) === -1)
                   shared = false;
               })
           return shared;
        })

---

我认为这应该行得通

var arr1 = [1,2,3,4]
  , arr2 = [2,3,4,5]
  , arr3 = [3,4,5,6]
  , arrs = [arr1, arr2, arr3];

var all = arr1.concat(arr2.concat(arr3)).sort()
  , red1 = all.filter(
        function(val, i, arr) {
          return i === arr.lastIndexOf(val)-1;
        })
  , red2 = red1.filter(
        function(val, i, arr) {
           var shared = true;
           arrs.forEach(
               function(arr, i, src) {
                 if (arr.indexOf(val) === -1)
                   shared = false;
               })
           return shared;
        })

---

像这样的方法应该会奏效：

function getCommonElements() {
   var common = [],
       i, j;

   if (arguments.length === 0)
      return common;

   outerLoop:
   for (i = 0; i < arguments[0].length; i++) {
      for (j = 1; j < arguments.length; j++)
         if (-1 === arguments[j].indexOf(arguments[0][i]))
             continue outerLoop;

      common.push(arguments[0][i]);
   }
   return common;
}

如果不是很明显，我们的想法是从第一个参数开始遍历数组，并对照其他数组测试它的每个元素。一旦发现某个特定元素不在其他参数的任何其他数组中，则继续下一个元素。否则，将当前元素添加到输出数组中，

common

---

如果您需要支持不支持的浏览器（即<9），您可以包括或用另一个循环替换我的代码中的

.indexOf（）

测试。

类似的方法应该可以：

function getCommonElements() {
   var common = [],
       i, j;

   if (arguments.length === 0)
      return common;

   outerLoop:
   for (i = 0; i < arguments[0].length; i++) {
      for (j = 1; j < arguments.length; j++)
         if (-1 === arguments[j].indexOf(arguments[0][i]))
             continue outerLoop;

      common.push(arguments[0][i]);
   }
   return common;
}

如果不是很明显，我们的想法是从第一个参数开始遍历数组，并对照其他数组测试它的每个元素。一旦发现某个特定元素不在其他参数的任何其他数组中，则继续下一个元素。否则，将当前元素添加到输出数组中，

common

---

如果您需要支持不支持的浏览器（即<9），您可以包括或用另一个循环替换我的代码中的

.indexOf（）

测试。

如果您只关心支持reduce（）的现代浏览器，则使用此解决方案：

如果您必须支持IE6，请使用下面的解决方案。下面是我如何使用jQuery在IE6中实现这一点的：

  // Find common values across all arrays in 'a',
  // where 'a' is an array of arrays [[arr1], [arr2], ...]
  Object.common = function(a) {
    var aCommon = [];
    for (var i=0,imax=a[0].length,nMatch,sVal; i<imax; i++) {
      nMatch = 0;
      sVal = a[0][i];
      for (var j=1,jmax=a.length; j<jmax; j++) {
        nMatch += ($.inArray(sVal, a[j])>-1) ? 1 : 0;
      }
      if (nMatch===a.length-1) aCommon.push(sVal);
    }
    return aCommon;
  }

//在“a”中的所有数组中查找公共值，
//其中“a”是数组的数组[[arr1]、[arr2]、…]
Object.common=函数（a）{
var aCommon=[]；
对于（var i=0，imax=a[0]。length，nMatch，sVal；i如果您只关心支持reduce（）的现代浏览器，请使用以下解决方案：


如果您必须支持IE6，请使用下面我的解决方案。下面是我如何使用jQuery在IE6中实现这一点的：

  // Find common values across all arrays in 'a',
  // where 'a' is an array of arrays [[arr1], [arr2], ...]
  Object.common = function(a) {
    var aCommon = [];
    for (var i=0,imax=a[0].length,nMatch,sVal; i<imax; i++) {
      nMatch = 0;
      sVal = a[0][i];
      for (var j=1,jmax=a.length; j<jmax; j++) {
        nMatch += ($.inArray(sVal, a[j])>-1) ? 1 : 0;
      }
      if (nMatch===a.length-1) aCommon.push(sVal);
    }
    return aCommon;
  }

//在“a”中的所有数组中查找公共值，
//其中“a”是数组的数组[[arr1]、[arr2]、…]
Object.common=函数（a）{
var aCommon=[]；
对于（var i=0，imax=a[0].length、nMatch、sVal；仅在
IE>=9
！中受支持，但在+1中受支持。仅在
IE>=9
！中受支持！但+1。不能真正遵循这一点。但我认为这是正确的方法。将所有数组和与数组数量一样频繁出现的值合并为共同值。这是一个很酷的示例，说明了如何用最少的e混淆即使是简单的javascriptffort.我同意@RobG.BadKnees甚至提到无法遵循它，但无论如何还是接受了它。（我的方式可能是日常的，但它最终变得更短，而且（在我看来）更容易遵循。）@nnnnnn-“日常的”？必须查一下那个。；-）好吧，昨天午夜过后，我显然太激动了。这个例子做了什么？连接数组以获得大量的值，这些值会被排序。第一个过滤器将返回一个值数组，该值是当前索引（indexOf（））匹配上一个索引。因此您将获得一组唯一的值。第二个筛选器将获取该组值并检查所有数组（使用forEach）如果它出现在所有数组中，则使用arrs数组，该数组包含对包含值的所有单个数组的引用。不能真正遵循此方法。但我认为这是正确的方法。Concat所有数组和经常出现的值都是共同的值。这是一个很酷的示例，演示了如何用最小的努力。我同意@RobG.BadKnees甚至提到无法遵循它，但无论如何还是接受了它。（我的方式可能是日常的，但它最终会变得更短，而且（在我看来）更容易遵循。）@nnnnnn-“日常的”？必须查一查好吧，昨天午夜过后，我显然太激动了。这个例子做了什么？连接数组以获得大量的值，这些值会被排序。第一个过滤器将返回一个值数组，该值是当前索引（indexOf（））匹配上一个索引。因此您将获得一组唯一的值。第二个筛选器将获取该组值并使用arrs数组检查所有数组（使用forEach），如果它存在于所有索引中，则使用arrs数组，该数组保存对包含值的所有单个数组的引用。