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

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 3

这是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 4

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

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

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

Answer 5

如果您也在寻找反向对-摆脱了@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]));

Answer 6

有了ECMAScript中的flatMap，有一个非常简单易读的选项可以无循环地在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，因此它使用字符串比较来检查数组是否相等。这适用于原始问题中的用例，但对于更复杂的示例，可能需要另一种检查重复项的方法。

如何获取所有数组JavaScript对

6 个答案: