Question

我遇到的问题是，我想像这样组合一个2D数组：

[
    [ "Renault", 61, 16, … ],
    [ "Ferrari", 58, 10, … ],
    [ "Mercedes", 32, 12, … ],
    [ "Mercedes", 24, 21, … ],
    [ "Toro Rosso", 7, 8, … ]
]

因此，在本示例中，我在数组的索引0处有两次字符串“ Mercedes”。我想要的输出是以下内容：

[
    [ "Renault", 61, 16, … ],
    [ "Ferrari", 58, 10, … ],
    [ "Mercedes", 56, 33, … ],
    [ "Toro Rosso", 7, 8, … ]
]

因此，如果类似“ Mercedes”的字符串在该数组中出现两次，我希望删除第二个。但是，第二个数组中的值必须转移到第一个“ Mercedes”数组中。

Answer 1

您可以使用reduce()来构建对象，然后使用Object.values()

const arr = [
    [ "Renault", 61, 16 ],
    [ "Ferrari", 58, 10],
    [ "Mercedes", 32, 12],
    [ "Mercedes", 24, 21],
    [ "Toro Rosso", 7, 8]
]

let res = arr.reduce((ac, [k, ...rest]) => {
  if(!ac[k]) ac[k] = [];
  ac[k] = ac[k].concat(k,...rest);
  return ac;
},[])
console.log(Object.values(res))

Answer 2

似乎您实际上想要在数组中聚合相似的值。因此，您可以在foreach中执行一个循环，并将自己已知的字符串值保存在一个临时数组中，而不是另一个合并的类中。到那时，当您滚动浏览数组时，可以检查是否已经在第一个假数组中添加了相等的字符串，如果是，则可以获取其索引并将其正确聚集在另一个数组中。

let arr = [
  ["Renault", 61, 16],
  ["Ferrari", 58, 10],
  ["Mercedes", 32, 12],
  ["Mercedes", 24, 21],
  ["Toro Rosso", 7, 8]
]
var tmp1 = [], tmp2 = [];
arr.forEach(function(currentValue, index, arr) {
    // currentValue contain your element
    // index contain the index of your element
    // arr contain you entire "values" array
    var ind = tmp1.indexOf(currentValue[0]);
    if(ind === -1) {
        tmp1.push(currentValue[0]);
        tmp2.push(currentValue);
    } else {
        tmp2[ind][1] += currentValue[1];
        tmp2[ind][2] += currentValue[2];
    }
});
console.log(tmp2);

Answer 3

当然，通过为您的名称创建一个数组，然后将它们与唯一的名称分开，最后，将它们与索引匹配。

let arr = [
  ["Renault", 61, 16],
  ["Ferrari", 58, 10],
  ["Mercedes", 32, 12],
  ["Mercedes", 24, 21],
  ["Toro Rosso", 7, 8]
]
let c = [...new Set(arr.map(a => a[0]))] // get unique values of all arr[0]
let ans = arr.filter((a, post) => { 
  if (c[post]) { // check if index exists because we seperated one, the last is undefined here
    if (a[0] == c[post]) {
      return a;
    }
  } else {
    return a; // else return as usual
  }
})
console.log(ans)

您将获得过滤后的数组。

Answer 4

如果要使用相同的键求和，则可以使用foreach语句来完成：

var fooArray = [
  [ "Renault", 61, 16],
  [ "Ferrari", 58, 10],
  [ "Mercedes", 32, 12],
  [ "Mercedes", 24, 21],
  [ "Toro Rosso", 7, 8]
];

function test(){
  let obj = {};
  fooArray.forEach(f=> {
    if (obj[f[0]]) {
      obj[f[0]][1] += f[1];
      obj[f[0]][2] += f[2];
    } else {          
      obj[f[0]]= { 0: f[0], 1: f[1], 2: f[2]};
    }
  })
  console.log('Your summed up values:', Object.values(obj));
}

console.log(test());

Answer 5

您可以遍历数组，并将已经用其index处理过的名称的映射对象保留在结果数组中，以便在需要添加更多值时可以更快地访问它们。

即：

{
 "Renault": 0,
  "Ferrari": 1,
  "Mercedes": 2,
  "ToroRosso": 3
}

这是一个正在运行的示例，其中包含以下步骤：

const arr = [
  ["Renault", 61, 16],
  ["Ferrari", 58, 10],
  ["Mercedes", 32, 12],
  ["Mercedes", 24, 21],
  ["Toro Rosso", 7, 8]
];

let map = {};
let globalIndex = 0;
let resultArray = [];
arr.forEach((currentArray) => {
  const [name, ...rest] = currentArray;
  if (map[name] === undefined) {
    // if our map doesn't already store this value
    // then store it with it's current index
    map[name] = globalIndex;
    // push it to the result array
    resultArray[globalIndex] = currentArray;
    // increment the global index 
    //so we can keep track of it in the next iteration
    globalIndex++;
  } else {
    // we already have an array with this name
    // grab the relevant index we previously stored
    // and push the items without the name via this index
    const relevantIdx = map[name];
    resultArray[relevantIdx] = [
      ...resultArray[relevantIdx],
      ...rest
    ]
  }
})

console.log(resultArray);

如果一个参数相同，则将2个数组合并为2D数组

5 个答案: