Javascript 在对象数组中循环以搜索原点->；目的地和目的地->；原点和拉力计数

我有一个包含起点和终点信息的对象数组，显示了从一个地方到另一个地方的对象的总体积。 我试图比较两个城市之间的流量。例如，在下面，当原点是温哥华，目的地是旧金山时，计数是5，但是当它被颠倒（原点是旧金山，目的地是温哥华）时，计数是12。

    InOut = [
      {
        "origin": "Pittsburgh, Pennsylvania",
        "dest": "New York, New York",
        "count": 5
      },
      {
        "origin": "Pittsburgh, Pennsylvania",
        "dest": "Newark, New Jersey",
        "count": 2
      },
      {
        "origin": "Los Angeles, California",
        "dest": "Seattle, Washington",
        "count": 6
      },
      {
        "origin": "Vancouver, Canada",
        "dest": "Brooklyn, New York",
        "count": 3
      },
      {
        "origin": "Detroit, Michigan",
        "dest": "New York, New York",
        "count": 4
      },
      {
        "origin": "Detroit, Michigan",
        "dest": "Washington, DC",
        "count": 11
      },
      {
        "origin": "Vancouver, Canada",
        "dest": "San Francisco, California",
        "count": 5
      },
      {
        "origin": "New York, New York",
        "dest": "Pittsburgh, Pennsylvania",
        "count": 9
      },
      {
        "origin": "New York, New York",
        "dest": "Detroit, Michigan",
        "count": 7
      },
      {
        "origin": "Philadelphia, Pennsylvania",
        "dest": "Baltimore, Maryland",
        "count": 12
      },
      {
        "origin": "Philadelphia, Pennsylvania",
        "dest": "New York, New York",
        "count": 6
      },
      {
        "origin": "Seattle, Washington",
        "dest": "Los Angeles, California",
        "count": 3
      },
      {
        "origin": "San Francisco, California",
        "dest": "Vancouver, Canada",
        "count": 12
      }
    ]

我知道我可以根据出发地和目的地查找计数，如下所示：

    function findValueByKey(array, key, value, key2, value2) {
        for (var i = 0; i < array.length; i++) {
            if (array[i][key] == value && array[i][key2] == value2) {
                return array[i].count;
            }
        }
        return null;
    }
    var obj = findValueByKey(InOut, 'origin', 'Vancouver, Canada', 'dest', 'San Francisco, California');
    var obj2 = findValueByKey(InOut, 'origin', 'San Francisco, California', 'dest', 'Vancouver, Canada');
    console.log('obj', obj)
    console.log('obj', obj2)

函数findValueByKey（数组、键、值、键2、值2）{
对于（var i=0；i

但是，我很难找出如何循环数组以获得所有计数。就我所知：

    allLocations = ["Pittsburgh, Pennsylvania", "Los Angeles, California", "Newark, New Jersey", "Seattle, Washington", "Vancouver, Canada", "Brooklyn, New York", "Detroit, Michigan", "Washington, DC", "New York, New York", "Philadelphia, Pennsylvania", "San Francisco, California"]

    origDestValues = []
    for(i=0; i< allLocations.length;i++){
      InOutA = findValueByKey(setOne, 'origin', allLocations[i], 'dest', allLocations[i])
      InOutB = findValueByKey(setOne, 'origin', allLocations[i], 'dest', allLocations[i])
      origDestValues.push({
          city1: allLocations[i],
          city2: allLocations[i],
          firstCount: InOutA,
          secondCount: InOutB
      });
    };

allLocations=[“宾夕法尼亚州匹兹堡”、“加利福尼亚州洛杉矶”、“新泽西州纽瓦克”、“华盛顿州西雅图”、“加拿大温哥华”、“纽约州布鲁克林”、“密歇根州底特律”、“华盛顿特区”、“纽约州纽约”、“宾夕法尼亚州费城”、“加利福尼亚州旧金山”]
origDestValues=[]
对于（i=0；i

显然，这是行不通的，因为它每次都会寻找相同的起点/目的地，但我认为这是朝着正确的方向发展的？在这里提问之前，我想证明我已经付出了一些努力

另外，值得一提的是，我的实际阵列更长（更多的城市）。为了回答这个问题，我把它简化了

---

感谢您提供的所有帮助。

您可以运行此代码以查看输出：

const inOut=[{
“原产地”：“宾夕法尼亚州匹兹堡”，
“目的地”：“纽约，纽约”，
“计数”：5
},
{
“原产地”：“宾夕法尼亚州匹兹堡”，
“目的地”：“新泽西州纽瓦克”，
“计数”：2
},
{
“原产地”：“加利福尼亚州洛杉矶”，
“目的地”：“西雅图，华盛顿”，
“计数”：6
},
{
“原产地”：“加拿大温哥华”，
“目的地”：“纽约布鲁克林”，
“计数”：3
},
{
“原产地”：“密歇根州底特律市”，
“目的地”：“纽约，纽约”，
“计数”：4
},
{
“原产地”：“密歇根州底特律市”，
“目的地”：“华盛顿特区”，
“计数”：11
},
{
“原产地”：“加拿大温哥华”，
“目的地”：“加利福尼亚州旧金山”，
“计数”：5
},
{
“来源”：“纽约，纽约”，
“目的地”：“宾夕法尼亚州匹兹堡”，
“计数”：9
},
{
“来源”：“纽约，纽约”，
“目的地”：“密歇根州底特律市”，
“计数”：7
},
{
“起源”：“宾夕法尼亚州费城”，
“目的地”：“马里兰州巴尔的摩”，
“计数”：12
},
{
“起源”：“宾夕法尼亚州费城”，
“目的地”：“纽约，纽约”，
“计数”：6
},
{
“起源”：“西雅图，华盛顿”，
“目的地”：“加利福尼亚州洛杉矶”，
“计数”：3
},
{
“原产地”：“加利福尼亚州旧金山”，
“目的地”：“加拿大温哥华”，
“计数”：12
}
]
//第一步。查找所有可能的城市：
const cities={}
//因为我们使用的是一个对象，所以不会有任何重复项
for（输入输出的常量单位）{
城市[单位.原点]={}
城市[unit.dest]={}
}
//第二步。生成所有城市到所有城市的矩阵：
for（城市中的const city1）{
用于（城市中的const city2）{
如果（city1！==city2）{//我们不需要dest==origin对
城市[城市1][城市2]={
至:0,，
起:0
}
}
}
}
//第三步。填充矩阵两次：一次用于目标，一次用于原点：
for（输入输出的常量）{
城市[io.origin][io.dest].to+=io.count
城市[io.dest][io.origin].from+=io.count
}
//第四步。或者，我们可以删除空对，其中to和from为0
for（城市中的const city1）{
用于（城市中的const city2[城市1]）{
如果（城市[city1][city2]。收件人===0&&cities[city1][city2]。发件人===0）{
删除城市[city1][city2]
}
}
}
log（“所有组合的列表：”）
console.log（城市）
log（“例如，关于一个城市（宾夕法尼亚州匹兹堡）的信息可以这样找到：”）
console.log（城市[“宾夕法尼亚州匹兹堡]）
log（“例如，宾夕法尼亚州匹兹堡市和纽约州纽约市之间的流量如下：”）
console.log（城市[“宾夕法尼亚州匹兹堡”][“纽约州纽约”]）
log（“您还可以检查相反的方向（纽约与纽约、纽约与宾夕法尼亚州匹兹堡之间的流量）：”）
console.log（城市[“纽约，纽约”][“宾夕法尼亚州匹兹堡”]）
log（“注意，对于不存在的对（没有事务），您将得到未定义的：”）
console.log（城市[“宾夕法尼亚州匹兹堡”][“加拿大温哥华”]）

Hey@sprucegoose，我的答案能满足您的需求吗？@IvanD Aweasome，谢谢！我感谢您对代码的解释。这正是我想要的，我已经接受了你的答案。非常感谢！