How to Group and Sum Slices of Structs in Go?

Grouping and Summing Slices of Structs in Go

The Problem

In programming, it is often necessary to perform data manipulation tasks on in-memory collections. One common operation is grouping data into categories and summing values within each category. This problem is often encountered when working with slices of structs.

The Challenge

Consider the following slice of structs:

<code class="go">type Register struct {
    id1 int
    id2 int
    id3 int
    id4 int
    id5 int
    id6 int
    id7 int
    id8 int
    money int
}</code>

The task is to group the elements in the slice by the first eight fields (the id fields) and sum the money fields for each group. This operation is analogous to the SQL query:

<code class="sql">SELECT SUM(money) FROM Registers GROUP BY id1, id2, id3, id4, id5, id6, id7, id8;</code>

The Solution

There are several ways to approach this problem in Go. One option is to use a hash table to track the sums for each unique combination of id fields.

1. Create a Key Type: Define a new struct called Key that contains only the id fields. This struct will serve as a unique identifier for each group.
2. Transform the Registers: Create a new slice where each element is a struct with a Key field and a money field. The Key field will be set to the corresponding key for the element, and the money field will remain unchanged.
3. Initialize a Map: Create a map that maps Key values to integer sums.
4. Iterate and Accumulate: Iterate over the transformed slice. For each element, retrieve the sum from the map using the element's Key, add the element's money field, and store the updated sum back into the map.

The following code demonstrates this approach:

<code class="go">type Key struct {
    id1 int
    id2 int
    id3 int
    id4 int
    id5 int
    id6 int
    id7 int
    id8 int
}

func groupAndSum(registers []*Register) map[Key]int {
    m := map[Key]int{}
    for _, r := range registers {
        key := Key{
            id1: r.id1,
            id2: r.id2,
            id3: r.id3,
            id4: r.id4,
            id5: r.id5,
            id6: r.id6,
            id7: r.id7,
            id8: r.id8,
        }
        m[key] += r.money
    }
    return m
}</code>

This solution provides an efficient way to group and sum structs based on their keys.

The above is the detailed content of How to Group and Sum Slices of Structs in Go?. For more information, please follow other related articles on the PHP Chinese website!