如何获取所有数组 JavaScript 对

Question

我需要使用所有可用的数组元素对来调用函数。像这样：

[1, 2, 3].pairs(function (pair) {
  console.log(pair); //[1,2], [1,3], [2,3]
});

Answer 1

您应该尝试向我们展示您自己解决了问题，而不是仅仅向我们询问答案，但这是一个有趣的问题，所以在这里：

Array.prototype.pairs = function (func) {
    for (var i = 0; i < this.length - 1; i++) {
        for (var j = i; j < this.length - 1; j++) {
            func([this[i], this[j+1]]);
        }
    }
}

var list = [1, 2, 3];
list.pairs(function(pair){
    console.log(pair); // [1,2], [1,3], [2,3]
});

http://jsfiddle.net/J3wT5/

Answer 2

感谢 ECMAScript 标准的不断发展..

let pairs = (arr) => arr.map( (v, i) => arr.slice(i + 1).map(w => [v, w]) ).flat();

pairs([1, 2, 3, 4, 5]);

Answer 3

function pairs(arr) {
    var res = [],
        l = arr.length;
    for(var i=0; i<l; ++i)
        for(var j=i+1; j<l; ++j)
            res.push([arr[i], arr[j]]);
    return res;
}
pairs([1, 2, 3]).forEach(function(pair){
    console.log(pair);
});

Answer 4

这是一个没有突变的 ES6 风格的变体：

const pairsOfArray = array => (
  array.reduce((acc, val, i1) => [
    ...acc,
    ...new Array(array.length - 1 - i1).fill(0)
      .map((v, i2) => ([array[i1], array[i1 + 1 + i2]]))
  ], [])
) 

const pairs = pairsOfArray(['a', 'b', 'c', 'd', 'e'])
console.log(pairs)

// => [['a','b'], ['a','c'], ['a','d'],['a','e'],['b','c'],['b','d'],['b','e'],['c','d'],['c','e'],['d','e']]

Answer 5

flatMap 现在在 ECMAScript 中可用，有一个非常简单且可读的选项可以在 Javascript 中查找列表中的项目对，而无需循环：

const pairs = (a) => {
    
    return a.flatMap( (x) => {
        return a.flatMap( (y) => {
            return (x != y) ? [[x,y]] : []
        });
    });
}

调用pairs([1,2,3])会输出：

[ [ 1, 2 ], [ 1, 3 ], [ 2, 1 ], [ 2, 3 ], [ 3, 1 ], [ 3, 2 ] ]

简单、易读且实用。

编辑：我最初将这个问题读作“如何获得所有对”，我认为它包括反向对，上面的例子就是这样。要返回没有倒序对的列表，我们可以用reduce() 取出这些：

const isInArray = (a, value) => {
    if (
        a.map((x) => {
            if (x.toString() == value.toString()) return true;
        }).includes(true)
    ){
        return true;
    }
};

const reducedPairs = (a) => {
    
    return a.flatMap( (x) => {
        return a.flatMap( (y) => {
            return (x != y) ? [[x,y]] : []
        });
    }).reduce( (unique, current) => {
        if (!isInArray(unique, current.slice().reverse())) unique.push(current);
        return unique;
    }, []);

}

请注意，这使用字符串比较来检查数组是否相等，因为[1,2] == [1,2] 是false。这适用于原始问题中的用例，但对于更复杂的示例，可能需要另一种检查重复项的方法。

Answer 6

这是我使用 ES6 能找到的最简洁的解决方案。它根据索引并使用 flatMap 函数生成唯一的对。

const uniquePairs = (arr) => 
  arr.flatMap((item1, index1) => 
    arr.flatMap((item2, index2) => 
      (index1 > index2) ? [[item1,item2]] : []
    )
  )

uniquePairs([1,2,3])
// [[2, 1], [3, 1], [3, 2]]

flatMap - 将元素返回到一个数组中，并具有能够完全删除空数组的好处。这就是让我们的值为[] 的三元组消失的原因！

像map一样，它可以返回索引，通过比较两个项目的索引，我们可以避免重复（第一个索引必须大于第二个才能添加元素）。

三元组让我们进行比较，如果为假则返回一个空数组（第二个 flatMap 完全忽略了该数组）。

通过将每个 flatMap 更改为 map，您可以更好地了解每个 flatMap 正在完成的工作 - 所以我鼓励您尝试更改它！

Answer 7

如果您也在寻找反向对 - 与上面 @Oriol 的答案不同 - 这是一个包含所有原始对 + 所有反向原始对的版本：

function allPairs (arr) {
  let pairs = [];
  for (let i = 0; i < arr.length; i++) {
    for (let j = i + 1; j < arr.length; j++) {
      pairs.push([arr[i], arr[j]]);
    }
  }
  let copy = pairs;
  pairs = JSON.stringify(pairs);
  let reversed = [];
  copy.forEach((value) => {
    reversed.push(value.reverse());
  })
  let final = [];
  final.push(JSON.parse(pairs).concat(reversed));
  return final[0];
}
console.log(allPairs([1, 2, 3, 4, 5]));