使用地圖按特定順序插入物件

我有一個用例，其中物件的順序需要按特定順序排列。當前的實作是通過 using 完成的map，我發現許多帖子和文章都指出這map是一個無序串列。我發現的所有解決方案都是那些將鍵設為整數并用于sort.Ints(keys)按鍵排序的解決方案。

在代碼中，我使用 yaml 模板來實體化一個字典對，然后將其傳遞給 ProcessFruits 函式，在那里它執行邏輯。

我將如何獲得所需的結果（見下文），其中 fruits.yml.tmpl 中串列頂部的物件將始終是第一個？

這是我的代碼的簡化版本：

//Filename: fruits.yml.tmpl

fruits: {{ $fruits := processFruits
  "oranges"    true
  "bananas"    false
  "apples"    true
  }}
  {{ $fruits }}

//Filename: fruits.go

func ProcessFruits(fruits map[string]interface{}) (interface{}) {
  keys := make([]string, len(fruits))

  i := 0
  for fruit := range fruits {
    keys[i] = fruit
    i  
  }

  sort.Strings(keys)
  fmt.Println(keys)
}

// Connect fruits.yml.tmpl to the ProcessFruits function
tmpl, err := template.New(t).Funcs(template.FuncMap(map[string]interface{}{
    "processFruits":        ProcessFruits,
})).Funcs(sprig.TxtFuncMap())

實際結果：

[蘋果：真香蕉：假橙子：真]

期望的結果：

[橙子：真香蕉：假蘋果：真]

去游樂場

https://go.dev/play/p/hK2AdRVsZXJ

uj5u.com熱心網友回復：

您缺少 sort.Reverse() 和 sort.StringSlice() 的用法

func main() {
    keys := []string{"bananas", "apples", "oranges"}
    sort.Sort(sort.Reverse(sort.StringSlice(keys)))
    fmt.Println(keys)
}

https://go.dev/play/p/n08S7xtbeij

見：https ://pkg.go.dev/sort#example-Reverse

uj5u.com熱心網友回復：

引數作為切片傳遞。將所有其他引數收集為字串并列印：

func ProcessFruits(args ...interface{}) interface{} {
    var fruits []string
    for i, arg := range args {
        if i%2 == 0 {
            fruits = append(fruits, arg.(string))
        }
    }
    fmt.Println(fruits)
    return nil
}

uj5u.com熱心網友回復：

不是最漂亮的解決方案，但我想我已經找到了解決問題的有效代碼。我所做的是創建另一個字典來跟蹤“水果”的順序，然后將兩個字典與嵌套的 for 回圈組合在一起并將結果輸出到切片。

這是我的代碼：

package main

import (
    "fmt"
    "sort"
)

func ProcessFruits(fruits map[string]interface{}, counts map[int]string) {
    keys := make([]string, len(fruits))
    var foo []string
    var baz []int

    for k := range fruits {
        foo = append(foo, k)
    }
    for _, k := range foo {
        fmt.Println("Key-string:", k, "Value-bool:", fruits[k])
    }

    fmt.Println("==========================")

    // Iterate over counts (keys are ints)
    for l := range counts {
        baz = append(baz, l)
    }
    sort.Ints(baz)
    for _, l := range baz {
        fmt.Println("Key-int:", l, "Value-string:", counts[l])
    }

    fmt.Println("==========================")
    // Correlate list with sorted integer keys with the other list that contains true/false

    i := 0
    for _, m := range baz {
        for _, n := range foo {
            //fmt.Println("Key-int:", m, "Value-string:", counts[m])
            //fmt.Println("Key-string:", n, "Value-bool:", fruits[n])

            if counts[m] == n {
                keys[i] = n
                i  
                //fmt.Println(i)
            }

        }
    }

    // Desired results is now in the slice, keys.
    fmt.Println(keys)

}

func main() {

    var m = map[string]interface{}{
        "oranges": true,
        "bananas": false,
        "apples":  true,
    }

    var n = map[int]string{
        0: "oranges",
        1: "bananas",
        2: "apples",
    }

    ProcessFruits(m, n)

}

如果有人有更好的解決方案，那么我很想知道。

標籤：字典 走 哈希图 映射

上一篇：Bash-如何將串列分配給陣列成員

下一篇：React：根據值型別渲染物件