数组JavaScript求和

我正在尝试使用total buy和total sell获取阵列。但是，看起来很难找到出路

我对数组进行了迭代，但无法通过任何方式显示带名称的买卖总额

const orders=[
['AAPL'，'buy'，100]，
[GOOG'，sell'，10]，
['AAPL'，'buy'，100]，
[AAPL'，'sell'，100]，
[AAPL'，sell'，20]，
];
函数变换（顺序）{
const result={}；
orders.forEach（元素=>{
})
返回结果；
}

---

使用

数组。减少
并检查第二个条目（操作）以将金额添加到正确的位置：


const orders=[
[“AAPL”，“购买”，100]，
[“GOOG”，“sell”，10]，
[“AAPL”，“购买”，100]，
[“AAPL”，“出售”，100]，
[“AAPL”，“出售”，20]
];
const result=orders.reduce（（acc、[键、动作、金额]）=>{
acc[键]=acc[键]| |[0,0]；
if（action==“buy”）acc[key][0]+=金额；
如果（动作==“卖出”）acc[键][1]+=金额；
返回acc；
}, {});
控制台日志（结果）您可以获取一个对象作为结果，以及获取正确索引的类型


函数变换（顺序）{
退货订单。减少（（结果，[键，类型，值]）=>{
结果[键]=结果[键]| |[0,0]；
结果[键][{买：0，卖：1}[类型]]+=值；
返回结果；
}, {});
}
常量订单=['AAPL'，'buy'，100]，'GOOG'，'sell'，10]，'AAPL'，'buy'，100]，'AAPL'，'sell'，100]，'AAPL'，'sell'，20]；
console.log（转换（订单））
.as控制台包装{max height:100%！important；top:0；}
您正在寻找类似的东西吗？不过，这可能不是一个优雅的解决方案


const orders=[
['AAPL'，'buy'，100]，
[GOOG'，sell'，10]，
['AAPL'，'buy'，100]，
[AAPL'，'sell'，100]，
[AAPL'，sell'，20]，
];
函数变换（顺序）{
const result={}；
orders.forEach（（[交易、类型、金额]）=>{
如果（！结果[事务]）{
结果[交易]=[0,0]；
}
结果[交易记录][类型=='购买'？0:1]+=金额；
})
返回结果；
}
让结果=变换（顺序）；
控制台日志（结果）这是您需要的吗


const orders=[
['AAPL'，'buy'，100]，
[GOOG'，sell'，10]，
['AAPL'，'buy'，100]，
[AAPL'，'sell'，100]，
[AAPL'，sell'，20]，
];
函数变换（顺序）{
var totalBuy=0，totalSell=0；
orders.map（order=>{
如果（订单[1]=“购买”）
totalBuy+=订单[2]；
否则如果（订单[1]=“卖出”）
totalSell+=订单[2]；
})
log（{totalBuy，totalSell}）
}
转换（命令）以下是一种方法：


const orders=[
['AAPL'，'buy'，100]，
[GOOG'，sell'，10]，
['AAPL'，'buy'，100]，
[AAPL'，'sell'，100]，
[AAPL'，sell'，20]，
];
const result={}；
orders.map（（订单）=>{
常量[标记、类型、金额]=订单；
如果（！result[tag]）result[tag]=[0,0]；
如果（type==“buy”）结果[tag]=[result[tag][0]+金额，结果[tag][1]]；
如果（类型==“销售”）结果[标签]=[结果[标签][0]，结果[标签][1]+金额]；
});
控制台日志（结果）请尝试以下操作：

const data = {};
orders.forEach(innerArray => {
    const [product, action, price] = innerArray;
    data[product] = data[product] || [0, 0]

    data[product][action === 'buy' ? 0 : 1] += +price

    return data
})

因为其他人都在使用函数式编程，所以循环有一种古老的方式：）

const orders=[
['AAPL'，'buy'，100]，
[GOOG'，sell'，10]，
['AAPL'，'buy'，100]，
[AAPL'，'sell'，100]，
[AAPL'，sell'，20]
];
函数变换（顺序）{
const result={}；
for（设i=0；i
有很多好的选项可供选择。这里还有另一个策略-将其包装在函数中并返回
results
对象（如果愿意）

let results = {};

orders.forEach(order => {
    if(!results[order[0]]) results[order[0]] = [0, 0];
    order[1] === 'buy' ? results[order[0]][0] += order[2] :
                         results[order[0]][1] += order[2]
});

使用


const transform=（）=>{
常量命令=[
['AAPL'，'buy'，100]，
[GOOG'，sell'，10]，
['AAPL'，'buy'，100]，
[AAPL'，'sell'，100]，
[AAPL'，sell'，20]，
];
退货订单。减少（（acc，订单）=>{
const isBuyOption=订单[1]=“购买”；
if（Array.isArray（acc[order[0]]））{
acc[订单[0]][0]=acc[订单[0]][0]+（isBuyOption？订单[2]：0）
acc[order[0]][1]=acc[order[0][1]+（！isBuyOption？order[2]：0）
}否则{
acc[订单[0]]=[
isBuyOption？订单[2]：0，
！isBuyOption？订单[2]：0
];
}
返回acc；
}, {});
}
const result=transform（）；
console.log（result）
我想我应该深入一些，这样你就有了思考的过程，而不仅仅是最终的代码。（我也是个爱唠叨的混蛋，喜欢写作。：D）

步骤1：考虑功能的整体流程
首先要考虑的是，即使在查看数据本身之前，也要查看数据要做什么。
首先，您需要在数组中循环，对数组中的每个项执行一些操作。这建议使用数组中内置的函数之一，例如
forEach
或
map
或
reduce
。所有这些元素都循环通过数组的元素，将每个元素传递给您定义的函数。但是他们用这些数据做不同的事情


forEach
允许您访问每个元素，但不希望您输出任何内容，只是出于某种原因使用这些信息。（您可以更改内容，但最好不要使用旧数据，而是创建一个新版本，这样您就可以始终知道自己拥有一组新数据，而不是直接调整内容。如果需要调整数据，请使用
map
，如下所述。）
map
允许您访问每个元素，但它希望您返回一些内容，以便根据从旧数组中获得的内容创建新数组。因此，如果你有一个数字数组，你想要一个不同的数组将这些数字转换成字符串，你可以创建一个函数，比如
（number