How to Deep Copy a Map and Then Clear the Original

In Go (Golang), maps are reference types, which means that copying a map only creates a shallow copy. To create a deep copy of a map, especially when it contains nested structures, you need to manually copy each element. Once the deep copy is created, you can then clear the original map. This blog post will guide you through the process.

Deep Copying a Map in Go
Let’s start by understanding the structure of a map in Go. A map is a collection of key-value pairs where each key is unique. Here’s how you can perform a deep copy of a map and then clear the original:

Step-by-Step Process

Define the Map Structure: Depending on the type of values your map holds, you might need to create custom types or structs.
Create a Deep Copy Function: This function will recursively copy each element of the map.
Clear the Original Map: This is straightforward in Go using the delete function within a loop.
Example
Consider a map with string keys and values of type interface{} to allow for nested structures. Here’s how you can deep copy such a map and clear the original:

Define the Original Map

package main

import (
    "fmt"
)
func main() {
    // Original map
    originalMap := map[string]interface{}{
        "key1": []int{1, 2, 3},
        "key2": map[string]string{"subkey1": "value1"},
    }

    // Perform deep copy
    deepCopiedMap := deepCopy(originalMap)

    // Clear the original map
    clearMap(originalMap)

    fmt.Println("Deep Copied Map:", deepCopiedMap)
    fmt.Println("Original Map after clearing:", originalMap)
}
Deep Copy Function

func deepCopy(original map[string]interface{}) map[string]interface{} {
    copy := make(map[string]interface{})
    for key, value := range original {
        switch v := value.(type) {
        case map[string]interface{}:
            copy[key] = deepCopy(v)
        case []interface{}:
            copy[key] = deepCopySlice(v)
        case []int:
            copy[key] = deepCopyIntSlice(v)
        default:
            copy[key] = value
        }
    }
    return copy
}

func deepCopySlice(original []interface{}) []interface{} {
    copy := make([]interface{}, len(original))
    for i, value := range original {
        switch v := value.(type) {
        case map[string]interface{}:
            copy[i] = deepCopy(v)
        case []interface{}:
            copy[i] = deepCopySlice(v)
        default:
            copy[i] = value
        }
    }
    return copy
}

func deepCopyIntSlice(original []int) []int {
    copy := make([]int, len(original))
    copy(copy, original)
    return copy
}
Clear Function

func clearMap(original map[string]interface{}) {
    for key := range original {
        delete(original, key)
    }
}

 
Explanation
Deep Copy Function:

The deepCopy function creates a new map and iterates over the original map.
It checks the type of each value and recursively copies maps and slices.
For basic types, it assigns the value directly.
Slice Handling:

The deepCopySlice function handles slices of interface{} by recursively copying each element.
The deepCopyIntSlice function handles slices of integers directly using the copy function.
Clearing the Map:

The clearMap function iterates over the original map’s keys and deletes each one.
By following this approach, you ensure that you create a true deep copy of your map, preserving the integrity of your data, and then clear the original map efficiently. This is particularly useful when you need to reuse the original map without carrying over any previous data.