利用字符串分割和键值对创建嵌套映射

哈喽！大家好，很高兴又见面了，我是golang学习网的一名作者，今天由我给大家带来一篇《利用字符串分割和键值对创建嵌套映射》，本文主要会讲到等等知识点，希望大家一起学习进步，也欢迎大家关注、点赞、收藏、转发! 下面就一起来看看吧！

我正在尝试根据返回项目接口的 api 调用生成值映射。{}我真的不知道如何更好地解释它，但这是我的情况。

我正在使用 vault 来存储机密，这些机密将生成要在集群编排器中使用的动态映射。一个例子是：

秘密/集群

秘密/集群可以有无限嵌套的秘密，例如

secret/cluster/team1/secreta/

secret/cluster/team2/secretb/app1/
secret/cluster/global

secret/cluster/team1/secreta 将具有表示秘密的键值对

例如

secret/cluster/team1/secreta
username: user
password: pass
database: db1

secret/cluster/team1
checksum: xxxxx

我编写了一个函数，它将迭代每个嵌套集群并返回需要检查的每个路径的切片：

func getchildsecrets(path string) []string {

    for _, v := range vault.list(path) {
        if strings.hassuffix(v, "/") {
            return append([]string{path}, getchildsecrets(fmt.sprintf("%s%s", path, v))...)
        }
    }
    return []string{path}
}

我的下一步是根据名称秘密路径及其值设置 map[string]interface{}：

map[cluster][team1][secreta]{username: user, password: pass, database:db1}
map[cluster][team1]{checksum:xxxx}

解决方案

如果我正确理解您的问题，您正在尝试将 vault 的路径转换为 ​​map[string] 接口{}？这不会很有帮助，因为您必须在每次读取时执行类型断言。请注意，这是针对 vault 的非常昂贵的 n^2 操作，并且您提出的算法可能会丢失数据，因为文件夹和叶子共享相同名称是有效的。尽管如此，还是给你吧。我想您会发现它比您想象的要复杂得多：

package main

import (
    "encoding/json"
    "fmt"
    "strings"

    vault "github.com/hashicorp/vault/api"
)

func main() {
    // Create a client object.
    client, err := vault.NewClient(vault.DefaultConfig())
    if err != nil {
        panic(err)
    }

    // Convert everything at the path to a map. This will only work with KV v1.
    m, err := SecretsToMap(client, "secret/")
    if err != nil {
        panic(err)
    }

    // Dump the result as JSON for easier viewing.
    j, err := json.MarshalIndent(m, "", "  ")
    if err != nil {
        panic(err)
    }
    fmt.Printf("%s", j)
}

// SecretsToMap recursively reads all paths in the root and converts them to a
// map by each path segment.
func SecretsToMap(client *vault.Client, root string) (map[string]interface{}, error) {
    var m = make(map[string]interface{})
    if err := secretsToMap(client, m, root); err != nil {
        return nil, err
    }
    return m, nil
}

func secretsToMap(client *vault.Client, m map[string]interface{}, root string) error {
    // List everything at this path
    r, err := client.Logical().List(root)
    if err != nil {
        return fmt.Errorf("failed to list %s: %s", root, err)
    }

    // Do nothing if the leaf is empty - this might be undesireable depending on
    // your use case (you may want the empty leaf here with {}). Modify as
    // appropriate.
    if r == nil || len(r.Data) == 0 {
        return nil
    }

    // Type conversions to get the response as []string.
    keysRaw, ok := r.Data["keys"]
    if !ok {
        return nil
    }
    keys, ok := keysRaw.([]interface{})
    if !ok {
        return fmt.Errorf("%q is not []interface{}", keysRaw)
    }
    list := make([]string, len(keys))
    for i, v := range keys {
        str, ok := v.(string)
        if !ok {
            return fmt.Errorf("%q is not string", v)
        }
        list[i] = str
    }

    // Iterate over each response
    for _, v := range list {
        // pth is the full path (root + child)
        pth := root + v

        // If this is a folder, recurse.
        if strings.HasSuffix(v, "/") {
            if err := secretsToMap(client, m, pth); err != nil {
                return err
            }
        } else {
            // Not a folde,r read the secret, handing errors and nil/empty data
            secret, err := client.Logical().Read(pth)
            if err != nil {
                return fmt.Errorf("failed to read secret %s: %s", pth, err)
            }

            // This might not be what you want - modify as appropriate.
            if secret == nil || secret.Data == nil {
                return nil
            }

            // Iterate over the folder parts and make a map entry if it does not
            // exist. This will panic and fail if you have leafs and folders with the
            // same name, but I'm just following your example.
            ptr := m
            for _, v := range strings.Split(root, "/") {
                p := strings.Trim(v, "/")
                if p == "" {
                    continue
                }

                // If there's no value at ptr (which is a moving target within the map),
                // create a container for data.
                if _, ok := ptr[p]; !ok {
                    ptr[p] = map[string]interface{}{}
                }

                // Advance the map pointer deeper into the map.
                ptr = ptr[p].(map[string]interface{})
            }

            // We've reached the leaf, set the data.
            ptr[v] = secret.Data
        }
    }

    return nil
}

终于介绍完啦！小伙伴们，这篇关于《利用字符串分割和键值对创建嵌套映射》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！