来自数组 JavaScript 的总和

Question

I am trying to get array with total buy and total sell. But, it looks very hard to find way.

I Iterate over array but, couldn't get any way to display sum of buy and sell with name.

 const orders = [ ['AAPL', 'buy', 100], ['GOOG', 'sell', 10], ['AAPL', 'buy', 100], ['AAPL', 'sell', 100], ['AAPL', 'sell', 20], ]; function transform(orders) { const result = {}; orders.forEach(element => { }) return result; }

 <div id="result"></div>

I want output like:

/*
result = {
    // total_buy, total_sell
    'AAPL': [ 200, 120 ],
    'GOOG': [ 0, 10]
}
*/

Any help would be greatly appreciated.

Answer 1

Use Array.reduce and check for the second entry ( action ) to add the amount to the right position :

 const orders = [ ["AAPL", "buy", 100], ["GOOG", "sell", 10], ["AAPL", "buy", 100], ["AAPL", "sell", 100], ["AAPL", "sell", 20] ]; const result = orders.reduce((acc, [key, action, amount]) => { acc[key] = acc[key] || [0, 0]; if (action === "buy") acc[key][0] += amount; if (action === "sell") acc[key][1] += amount; return acc; }, {}); console.log(result);

Answer 2

You could take an object as result and the type for getting the right index.

 function transform(orders) { return orders.reduce((result, [key, type, value]) => { result[key] = result[key] || [0, 0]; result[key][{ buy: 0, sell: 1 }[type]] += value; return result; }, {}); } const orders = [['AAPL', 'buy', 100], ['GOOG', 'sell', 10], ['AAPL', 'buy', 100], ['AAPL', 'sell', 100], ['AAPL', 'sell', 20]]; console.log(transform(orders));

 .as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 3

Here is one way you could do it:

 const orders = [ ['AAPL', 'buy', 100], ['GOOG', 'sell', 10], ['AAPL', 'buy', 100], ['AAPL', 'sell', 100], ['AAPL', 'sell', 20], ]; const result = {}; orders.map((order) => { const [ tag, type, amt ] = order; if (!result[tag]) result[tag] = [0, 0]; if (type == "buy") result[tag] = [result[tag][0] + amt, result[tag][1]]; if (type == "sell") result[tag] = [result[tag][0], result[tag][1] + amt]; }); console.log(result);

Answer 4

Since everyone else is going with functional programming, here is an old fashion for loop :)

const orders = [
    ['AAPL', 'buy', 100],
    ['GOOG', 'sell', 10],
    ['AAPL', 'buy', 100],
    ['AAPL', 'sell', 100],
    ['AAPL', 'sell', 20]
];

function transform(orders) {
    const result = {};

    for (let i = 0; i < orders.length; i++) {
        const [key, op, val] = orders[i];

        if (!result[key]) { result[key] = [0, 0]; }

        result[key][op === 'buy' ? 0 : 1] += val;
    }

    return result;
}

console.log(transform(orders));

Answer 5

Use Array.reduce()

 const transform = () => { const orders = [ ['AAPL', 'buy', 100], ['GOOG', 'sell', 10], ['AAPL', 'buy', 100], ['AAPL', 'sell', 100], ['AAPL', 'sell', 20], ]; return orders.reduce((acc, order) => { const isBuyOption = order[1] === 'buy'; if (Array.isArray(acc[order[0]])) { acc[order[0]][0] = acc[order[0]][0] + (isBuyOption ? order[2] : 0) acc[order[0]][1] = acc[order[0]][1] + (!isBuyOption ? order[2] : 0) } else { acc[order[0]] = [ isBuyOption ? order[2] : 0, !isBuyOption ? order[2] : 0 ]; } return acc; }, {}); } const result = transform(); console.log(result)

Answer 6

I figured I'd go deep, so you'd have the thought process, not just the final code. (Also I'm a wordy bastard and love writing. :D )

Step 1: Consider the overall flow of your function

The first thing to consider, before even looking at the data itself, is looking at what you want to do with the data.

First off, you want to loop through the array to do some stuff with each item in it. This suggests using one of the functions built into arrays, such as forEach or map or reduce . These all loop through the array's elements, passing each element to a function you define. But they do different things with that data.

• forEach gives you access to each element, but doesn't expect you to output anything, just using the information for some reason. (You can change things, but it's considered a good idea to leave old data alone and create a new version, so that you always know you've got a fresh set of data, instead of tweaking things directly. If you need to tweak the data, use map , described next.)
• map gives you access to each element, but it expects you to return something, to create a new array based on what you got from the old array. So if you, say, have an array of numbers, and you want a different array that has those numbers converted to strings, you could create a function like (number) => '' + number , pass it to map , and then you'd end up with a new array with all of your numbers converted to strings.
• reduce gives you access to each element, but instead of creating a new array, it lets you combine the information, reducing it to some form of single value or object. This is the method we're going to use, because we want to take the elements in the array and plug them into a single object that combines the information.

We could have used a for loop to do this, too, but by using the built-in functions, we can focus on just the work that is important to us -- combining the information -- and let the array do the housekeeping work of looping through each item. This will get clearer as we put everything together below.

Step 2: Figure out how to transform your data

The next step is knowing how you want to transform your data. Once you have that, then you can figure out how to add the entries together.

If you look at your transactions, each transaction looks like:

[name, buy or sell, amount]

What you want at the end is an object with keys and values that look like

name: [buy amount, sell amount]

Once you've seen that, the key is figuring out how to get from one arrangement to the other.

Handling the name is pretty straightforward. You'll just pass it from the array to the object, without any need to transform it:

const name = transaction[0];

The next thing to consider is how to split the buy and sell amounts into separate fields. If buys should be at index 0, and sells at index 1, it could be as simple as:

const amountIndex = transaction[1] === 'buy' ? 0 : 1;

The last item is the actual amount:

const amountValue = transaction[2];

Then, ignoring how to add these together, if we had a resultsObject to plug this into, we end up with

const name = transaction[0];
const amountIndex = transaction[1] === 'buy' ? 0 : 1;
const amountValue = transaction[2];

// create a new array with starting values
resultsObject[name] = [0, 0];
// put the transaction's value in the right place
resultsObject[name][amountIndex] = amountValue;

Step 3: Figure out how to combine the entries together

There's a few things we didn't address in step 2:

1. How do we only create new entries if an entry doesn't exist yet? (We don't want to overwrite an existing array.)
2. How do we add values to an existing array?

This is actually straightforward, but good to consider in its own place, because without it, our results would be completely messed up.

The first question is answered by replacing the creation line above with:

// create a new array with starting values (if it doesn't already exist)
if (! resultsObject[name]) {
  resultsObject[name] = [0, 0];
}

The second question is answered by performing addition and assignment in the next line:

// add the transaction's value to the right place
resultsObject[name][amountIndex] += amountValue; // added the + sign

If we put this together, we have the basic meat of how we want to reduce the array into our object:

const name = transaction[0];
const amountIndex = transaction[1] === 'buy' ? 0 : 1;
const amountValue = transaction[2];

// create a new array with starting values (if it doesn't already exist)
if (! resultsObject[name]) {
  resultsObject[name] = [0, 0];
}
// add the transaction's value to the right place
resultsObject[name][amountIndex] += amountValue; // added the + sign

Step 4: Create the function we pass to reduce()

We almost have the entire reducer function built. We just have to add the function definition and return value:

const getTransactionSummary = (resultsObject, transaction) => {
  const name = transaction[0];
  const amountIndex = transaction[1] === 'buy' ? 0 : 1;
  const amountValue = transaction[2];

  // create a new array with starting values (if it doesn't already exist)
  if (! resultsObject[name]) {
    resultsObject[name] = [0, 0];
  }
  // add the transaction's value to the right place
  resultsObject[name][amountIndex] += amountValue; // added the + sign

  return resultsObject;
}

The function takes the value we're collecting (the accumulator ) and the current element in the array, and returns the updated accumulator.

There are two key things to remember about any function you use in reduce :

1. The accumulator is always the first argument. This used to throw me off all the time, because I thought the array element would be the most important thing, so of course it's first! But no. The first value is the one being passed from element to element, the one accumulating data as you go through the array. Something to keep track of as you write more reducers.
2. Always return the accumulator. It's going to be passed along into each function call, but if you don't return it, the next element will get an undefined accumulator. If you get a TypeError in a reducer, check to make sure you're returning a value.

Step 5: Plug the reducer function into reduce

The final step to get a working transaction summary:

const getTransactionSummary = (resultsObject, transaction) => {
  const name = transaction[0];
  const amountIndex = transaction[1] === 'buy' ? 0 : 1;
  const amountValue = transaction[2];

  if (! resultsObject[name]) {
    resultsObject[name] = [0, 0];
  }
  resultsObject[name][amountIndex] += amountValue;

  return resultsObject;
}

const transactionSummary = transactions.reduce(getTransactionSummary, {});

(I removed the comments to clean it up a bit. The code itself is pretty self-explanatory, and the comments broke up the flow in the final product.)

That's it. That last line takes your array (named transactions here) and calls its reduce function. We give it the reference to our reducer, and an initial value to plug in as the resultsObject the first time around. It returns the fully populated resultsObject, with the transactions combined the way we want. (If we didn't include the {} as an initial value, we'd get another TypeError when the browser complained that you didn't have an accumulator defined.)

There are three things to notice when you compare this to a for loop:

• It's tight. There's no loop index to worry about, no condition to check, no extra brackets. It's one function, and one line.

• It's declarative. Instead of having to read all of the mechanics of looping and aggregating data, you get an idea of what's going on, simply by reading left-to-right:

  1. Define a variable named transactionSummary
  2. Look at the transactions array
  3. reduce that array...
  4. ...using getTransactionSummary

  By defining our code in a function, and plugging that function in as an argument to reduce, we can almost create a sentence out of our code. That can help us improve readability. In addition to making that single line concise, it also simplifies our function. The function starts at the top and works straight down, with one condition. The fewer conditions we need to check, the fewer loops we need to track, the easier it is to keep track of what's going on.

• It's pluggable. In this case, we want to create a transaction summary, so getTransactionSummary is useful for reducing our transactions. If we wanted to count the total number of buys and sells to get the overall volume, we could create a different function, say, getTransactionVolume . As long as it takes an accumulator and an array element, and returns the updated accumulator, we can replace getTransactionSummary with getTransactionVolume and get completely different statistics from the same data.

These three elements (especially the second and third ones) are what makes functional programming so nifty. There are a whole bunch of articles on what functional programming is, and how it works in JavaScript. Have fun googling!

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce

Answer 7

Are you looking for something like this? It is probably not an elegant solution though.

 const orders = [ ['AAPL', 'buy', 100], ['GOOG', 'sell', 10], ['AAPL', 'buy', 100], ['AAPL', 'sell', 100], ['AAPL', 'sell', 20], ]; function transform(orders) { const result = {}; orders.forEach(([transaction, type, amount]) => { if (!result[transaction]) { result[transaction] = [0, 0]; } result[transaction][type === 'buy' ? 0 : 1] += amount; }) return result; } let result = transform(orders); console.log(result);

Answer 8

Is this what you needed?

 const orders = [ ['AAPL', 'buy', 100], ['GOOG', 'sell', 10], ['AAPL', 'buy', 100], ['AAPL', 'sell', 100], ['AAPL', 'sell', 20], ]; function transform(orders) { var totalBuy = 0, totalSell = 0; orders.map(order => { if (order[1] == 'buy') totalBuy += order[2]; else if (order[1] == 'sell') totalSell += order[2]; }) console.log({totalBuy, totalSell}) } transform(orders);

Answer 9

Try this:

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
})

Answer 10

Lot's of fine options to choose from. Here's another strategy - wrap it in a function and return the results object if you'd prefer.

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]
});