每次在 Golang 中运行代码时，映射结果都不稳定

在 Go 语言中运行的代码中，映射结果的不稳定性源于 Go 映射的无序特性。每次运行时，映射中的键的顺序都会发生变化，导致检索值的方式不同。解决此问题的一种方法是对映射键进行排序，或使用有序切片作为映射键。通过这些方法，代码可以确保每次运行时以相同顺序访问映射值，从而产生一致的结果。

我当时正在做去年的 advent of code 的第 7 天，并用 python 解决了它（就像这样）。

我正在尝试学习 go，并在 go 中尝试了类似的方法。我将所有关系存储在 map 中，如下所示：

map[basecolour1:[colours{subcolour1, noofbags}, colours{subcolour2, noofbags}...], basecolour2:...

这是迄今为止的完整代码：

package main
import (
    "bufio"
    "fmt"
    "os"
    "regexp"
    "strings"
    "strconv"
)

// Part 1
// Find relation between all the colours
type Colours struct {
    subColour   string
    noOfBag     int
}

// To reuse for Part 2
func relationBetweenColours(input [][]string) (relation map[string][]Colours) {
    relation = make(map[string][]Colours)

    for _, rule := range input {
        baseColour := strings.Join(rule[:2], " ")
        relation[baseColour] = make([]Colours, 0)

        for i := range rule {
            match, _ := regexp.MatchString("\\d", rule[i])
            if match {
                subColour := strings.Join(rule[i + 1:i + 3], " ")
                noOfBag, _ := strconv.Atoi(rule[i])
                relation[baseColour] = append(relation[baseColour], Colours{subColour, noOfBag})
            }
        }
    }
    return
}

func checkMembership(input []string, element string) (bool) {
    for _, value := range input {
        if (value == element) { return true }
    }
    return false
}

func part1(relation map[string][]Colours) (count int) {
    // Strip relation of extra information
    relevantRelation := make(map[string][]string)

    for baseColour, arrayOfColours := range relation {
        relevantRelation[baseColour] = make([]string, 0)

        for _, colour := range arrayOfColours {
            relevantRelation[baseColour] = append(relevantRelation[baseColour], colour.subColour)
        }
    }

    // Add indirectly related colours
    for baseColour, arrayOfColours := range relevantRelation {
        for _, colour := range arrayOfColours {
            // Get an array of all colours which is not linked to baseColour
            for _, subColour := range relevantRelation[colour] {
                if !checkMembership(relevantRelation[baseColour], subColour) {
                    relevantRelation[baseColour] = append(relevantRelation[baseColour], subColour)
                }
            }
        }
    }

    // Add no. of colours which can eventually contain a "shiny gold" bag
    for _, arrayOfColours := range relevantRelation {
        if checkMembership(arrayOfColours, "shiny gold") {
            count++
        }
    }
    return
}

func main() {
    // Read input
    file, _ := os.Open("input.txt")
    defer file.Close()

    scanner := bufio.NewScanner(file)
    var input [][]string

    for scanner.Scan() {
        rule := strings.Split(scanner.Text(), " ")
        input = append(input, rule)
    }

    relation := relationBetweenColours(input)
    fmt.Println(part1(relation))
}

当我针对问题中给出的小样本输入尝试代码时，它产生了正确的结果。

然而，在针对给我的完整输入运行它时，它每次都会产生看似不同且错误的结果。输出介于 10 到 50 之间，并且每次都会发生变化（第 1 部分的输入的正确答案是 213）。

我的问题是：

1. 到底发生了什么导致每次结果不同？
2. 我可以做什么来克服这个问题并解决这个问题？

正确答案

golang 地图没有排序。因此，您存储和检索值的方式将影响订单的读取方式。您可以做的一件事是根据需要对地图键进行排序，然后使用它。或者您可以创建一个带有要映射的索引/键的切片。这将具有您设置的顺序。

func getorderedkeys(mymap map[string][]colours) []string {
    keys := make([]string, 0)
    for k, _ := range collection {
        keys = append(keys, k)
    }
    sort.strings(keys)
    return keys
}

现在，每次使用此地图时，都会获取排序后的键，然后使用这些键来获取地图值。

如果您不想对键进行排序，您可以做的其他事情是创建一个切片并将其用作有序键。

func relationBetweenColours(input [][]string) (relation map[string][]Colours, keys []string) {
    relation = make(map[string][]Colours)

    for _, rule := range input {
        baseColour := strings.Join(rule[:2], " ")
        relation[baseColour] = make([]Colours, 0)
        keys = append(keys, baseColour)
        
        ...
    }
    return
}

然后使用这样生成的键来迭代地图。

底线是golang 地图没有排序。

理论要掌握，实操不能落！以上关于《每次在 Golang 中运行代码时，映射结果都不稳定》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！