如果第一个值相同，Javascript将第二个数组值添加在一起

对不起，如果标题不清楚的话。这对我来说有点难以解释，因为我在多个阵列方面做得不是很好

我有一个数组：

[[211000]，[21500]，[18100]，[18200]]

现在我想得到这个结果数组：

[[211500]，[18300]

我该怎么做呢

我尝试使用21和18作为数组键，但这样我就无法在

for

循环中使用数组进行

.length

计数。我最终得到了总共4个阵列，几乎可以让它正常工作

---

编辑：

我希望避免使用21和18值作为数组键

我还希望能够迭代生成的数组/对象，并使用21和18“键”对我的页面进行进一步的更改

---

感谢所有的回复

创建一个对象怎么样：

var arr = [ [21, 1000], [21, 500], [18, 100], [18, 200] ];
    obj = {};

for (i=0; i<arr.length; i++) {
    obj[arr[i][0]] = (obj[arr[i][0]] || 0) + arr[i][1];
}

// obj now equals {18: 300, 21: 1500} 
// obj[21] equals 1500 etc

var-arr=[[211000]、[21500]、[18100]、[18200]；
obj={}；
对于（i=0；i

可以使用相同的方法创建阵列：

var arr  = [ [21, 1000], [21, 500], [18, 100], [18, 200] ],
    arr2 = [];

for (i=0; i<arr.length; i++) {
    arr2[arr[i][0]] = (arr2[arr[i][0]] || 0) + arr[i][1];
}

// giving you the array [18: 300, 21: 1500]
// where arr2[18] equals 300

var arr=[[211000]、[21500]、[18100]、[18200]，
arr2=[]；
对于（i=0；i如何创建对象：

var arr = [ [21, 1000], [21, 500], [18, 100], [18, 200] ];
    obj = {};

for (i=0; i<arr.length; i++) {
    obj[arr[i][0]] = (obj[arr[i][0]] || 0) + arr[i][1];
}

// obj now equals {18: 300, 21: 1500} 
// obj[21] equals 1500 etc

var-arr=[[211000]、[21500]、[18100]、[18200]；
obj={}；
对于（i=0；i

可以使用相同的方法创建阵列：

var arr  = [ [21, 1000], [21, 500], [18, 100], [18, 200] ],
    arr2 = [];

for (i=0; i<arr.length; i++) {
    arr2[arr[i][0]] = (arr2[arr[i][0]] || 0) + arr[i][1];
}

// giving you the array [18: 300, 21: 1500]
// where arr2[18] equals 300

var arr=[[211000]、[21500]、[18100]、[18200]，
arr2=[]；
对于（i=0；i您肯定不需要任何
jQuery
来获得您要求的结果数组：

var one = [21, 18];
var two = [ [21, 1000], [21, 500], [18, 100], [18, 200] ];
var results = [];

for(var i in one) {
    results[i] = 0;

    for(var x in two)
        if(two[x][0] === one[i])
            results[i] = results[i] + two[x][1];

    results[i] = [one[i], results[i]];
}

此处
您绝对不需要任何
jQuery
来获取您要求的结果数组：

var one = [21, 18];
var two = [ [21, 1000], [21, 500], [18, 100], [18, 200] ];
var results = [];

for(var i in one) {
    results[i] = 0;

    for(var x in two)
        if(two[x][0] === one[i])
            results[i] = results[i] + two[x][1];

    results[i] = [one[i], results[i]];
}

此处
如果您的值不符合顺序，您可以使用以下命令：

小提琴：


javasript：

var array1=    [21, 18];
var array2 =   [ [21, 1000], [21, 500], [18, 100], [18, 200] ];
var result =   [ [0,0], [0,0] ];

for (i=0;i<array1.length;i++){

    result[0,i][0] = array1[i];

    for (j=0;j<array2.length;j++){

        var key = array2[i,j][0];
        var val = array2[i,j][1];

        if (  key == array1[i] ){
            result[0,i][1] += val;
        }
    }
}

vararray1=[21,18]；
var array2=[[211000]、[21500]、[18100]、[18200]；
var结果=[[0,0]，[0,0]]；
对于（i=0；i，如果您的值不符合顺序，您可以使用以下命令：

小提琴：


javasript：

var array1=    [21, 18];
var array2 =   [ [21, 1000], [21, 500], [18, 100], [18, 200] ];
var result =   [ [0,0], [0,0] ];

for (i=0;i<array1.length;i++){

    result[0,i][0] = array1[i];

    for (j=0;j<array2.length;j++){

        var key = array2[i,j][0];
        var val = array2[i,j][1];

        if (  key == array1[i] ){
            result[0,i][1] += val;
        }
    }
}

vararray1=[21,18]；
var array2=[[211000]、[21500]、[18100]、[18200]；
var结果=[[0,0]，[0,0]]；
对于（i=0；i这里有另一种可能性，它是使用，因此您需要有一个现代浏览器或使用许多“填隙片”/“多边形填充物”中的一种

Javascript

var first = [21, 18],
    second = [
        [21, 1000],
        [21, 500],
        [18, 100],
        [18, 200]
    ],
    store = {};
    result = [];


first.forEach(function (element) {
    second.forEach(function (pair) {
        var value;

        if (pair[0] === element) {
            value = store[element] || 0;
            store[element] = value + pair[1];
        }
    });

    if (typeof store[element] === "number") {
        result.push([element, store[element]]);
    }
});

console.log(result);

var first = [
        [21, 1000],
        [21, 500],
        [18, 100],
        [18, 200]
    ],
    store = {};
    result;

first.forEach(function (pair) {
    store[pair[0]] = (store[pair[0]] || 0) + pair[1];
});

result = Object.keys(store).map(function (key) {
    return [parseInt(key, 10), store[key]];
});

console.log(result);

在

更新：这是一个基于更新问题的解决方案，它还使用and将对象转换为OP请求的数组格式

Javascript

var first = [21, 18],
    second = [
        [21, 1000],
        [21, 500],
        [18, 100],
        [18, 200]
    ],
    store = {};
    result = [];


first.forEach(function (element) {
    second.forEach(function (pair) {
        var value;

        if (pair[0] === element) {
            value = store[element] || 0;
            store[element] = value + pair[1];
        }
    });

    if (typeof store[element] === "number") {
        result.push([element, store[element]]);
    }
});

console.log(result);

var first = [
        [21, 1000],
        [21, 500],
        [18, 100],
        [18, 200]
    ],
    store = {};
    result;

first.forEach(function (pair) {
    store[pair[0]] = (store[pair[0]] || 0) + pair[1];
});

result = Object.keys(store).map(function (key) {
    return [parseInt(key, 10), store[key]];
});

console.log(result);

在
上，还有一种可能性，它是使用，因此您需要有一个现代化的浏览器或使用许多“填隙片”/“多边形填充物”中的一种

Javascript

var first = [21, 18],
    second = [
        [21, 1000],
        [21, 500],
        [18, 100],
        [18, 200]
    ],
    store = {};
    result = [];


first.forEach(function (element) {
    second.forEach(function (pair) {
        var value;

        if (pair[0] === element) {
            value = store[element] || 0;
            store[element] = value + pair[1];
        }
    });

    if (typeof store[element] === "number") {
        result.push([element, store[element]]);
    }
});

console.log(result);

var first = [
        [21, 1000],
        [21, 500],
        [18, 100],
        [18, 200]
    ],
    store = {};
    result;

first.forEach(function (pair) {
    store[pair[0]] = (store[pair[0]] || 0) + pair[1];
});

result = Object.keys(store).map(function (key) {
    return [parseInt(key, 10), store[key]];
});

console.log(result);

在

更新：这是一个基于更新问题的解决方案，它还使用and将对象转换为OP请求的数组格式

Javascript

var first = [21, 18],
    second = [
        [21, 1000],
        [21, 500],
        [18, 100],
        [18, 200]
    ],
    store = {};
    result = [];


first.forEach(function (element) {
    second.forEach(function (pair) {
        var value;

        if (pair[0] === element) {
            value = store[element] || 0;
            store[element] = value + pair[1];
        }
    });

    if (typeof store[element] === "number") {
        result.push([element, store[element]]);
    }
});

console.log(result);

var first = [
        [21, 1000],
        [21, 500],
        [18, 100],
        [18, 200]
    ],
    store = {};
    result;

first.forEach(function (pair) {
    store[pair[0]] = (store[pair[0]] || 0) + pair[1];
});

result = Object.keys(store).map(function (key) {
    return [parseInt(key, 10), store[key]];
});

console.log(result);

在
函数聚合结果（索引、输入阵列）上{
var-ret=[]，tmp；
对于（var i=0；i
函数聚合结果（索引、输入阵列）{
var-ret=[]，tmp；
for（var i=0；iYou不能将
用于
，但实际上可以将
.each（）
用于对象。为什么不将数据作为对象存储在第二个数组中？如果在“second”中找不到“first”中的元素，或者如果在“second”中有一对，但在“first”中没有匹配的元素，则不清楚该怎么办。这可能会导致许多已给出的答案不正确。第一个数组似乎是多余的，因此无需再检查另一个数组。后更新。您不能对
使用
，但实际上可以使用
。each（）
用于对象。为什么不将数据作为对象存储在第二个数组中？如果在“second”中找不到“first”中的元素，或者在“second”中有一对元素，但在“first”中没有匹配的元素，则不清楚该怎么办。这可能会导致一些已经给出的答案不正确。第一个数组似乎是多余的，因此无需再对照另一个数组进行检查。更新后。@ryan-不确定我是否得到了它，为什么不起作用->？数组中的顺序不重要！抱歉，我弄错了，因为我在写其他东西。第二个ar的顺序但是，ray不要紧，他有两个数组，他正在检查第一个数组中的值与第二个数组中的值。您完全忽略第一个数组。我所说的
if
语句的意思是：如果他有上面的数组，但他的第一个数组看起来像这样怎么办
？我找的第一个数组缺少处理。@ryan-这就是对象的重点。数组没有键，它们只有索引，因此从第二个数组中的值创建对象时，很容易看到第一个数组中的值是否实际上是对象中的键，因为对象实际上有键。@adeneo你能解释一下
|
操作符是如何实现求和的吗？@jlmmns-你可以用for/in循环来实现，比如@ryan-我不确定我是否明白，为什么不起作用->？数组中的顺序不重要！对不起，我弄错了，因为我在写其他东西。第二个数组的顺序不重要，但是，他有2个数组，并且他正在检查第一个数组中的值与第二个数组中的值。您完全忽略第一个数组。我所说的
if
语句的意思是：如果他有上面的数组，但他的第一个数组看起来像这样怎么办
？我找的第一个数组缺少处理。@ryan-这就是对象的重点。数组没有键，它们只有索引，因此从第二个数组中的值创建对象时，很容易看到第一个数组中的值是否实际上是对象中的键，因为对象实际上有键。@ad你能解释一下t是什么吗