在Go中比较从API调用中提取的JSON信息

Golang不知道大家是否熟悉？今天我将给大家介绍《在Go中比较从API调用中提取的JSON信息》，这篇文章主要会讲到等等知识点，如果你在看完本篇文章后，有更好的建议或者发现哪里有问题，希望大家都能积极评论指出，谢谢！希望我们能一起加油进步！

我有一个像这样的 json 文件，我用它来更新服务器的信息：

{
  "environments": [
    {
      "environment": "dev",
      "features": [
        { "name": "newa", "enable": true },
        { "name": "newb", "enable": true }
      ]
    }
  ]
}

从服务器获取信息的 api 查询会返回如下 json 信息。我通过一个名为 apicall()

{
  "name": "default",
  "environments": [
    "dev",
    "prod"
  ],
  "features": [
    {
      "type": "release",
      "name": "newa",
      "createdat": "2022-01-01t11:01:53.054z",
      "lastseenat": null,
      "stale": false,
      "environments": [
        {
          "name": "dev",
          "enabled": true,
          "type": "dev",
          "sortorder": 100
        },
        {
          "name": "prod",
          "enabled": false,
          "type": "prod",
          "sortorder": 200
        }
      ]
    },
    {
      "type": "release",
      "name": "newb",
      "createdat": "2022-01-01t11:01:53.087z",
      "lastseenat": null,
      "stale": false,
      "environments": [
        {
          "name": "dev",
          "enabled": true,
          "type": "dev",
          "sortorder": 100
        },
        {
          "name": "prod",
          "enabled": false,
          "type": "prod",
          "sortorder": 200
        }
      ]
    }
  ],
  "members": 1,
  "version": 1
}

每次更新 json 文件（例如删除、创建和更新功能信息）时，新信息都应通过 api 调用在服务器中正确更新。

要删除、创建和更新服务器中的功能信息，我已经有一个函数调用apiupdate()。基本上我可以从 json 文件更新/创建/删除的是功能名称 environments.environment.features.name 并启用/禁用它 environments.environment.features.enable

每次更新文件时，都会触发一个函数将新信息更新到服务器中。因此，我必须将当前的 json 文件与从服务器提取的信息进行比较，以做出适当的更改。

到目前为止，我尝试的只是创建功能名称（如果 json 文件中不存在）：

func triggered(token string, filejson string) {

    data := featurevars(filejson)
    for _, env := range data.environments {
        for _, feature := range env.features {

            url := "xxxx"
            response := statusfeature(url, token)
            fmt.printf("response:%s", response)

            if response != "200 ok" {

                // calling apiupdate()
                apiupdate(url_base, token, feature.name)
            }
        }
    }
}

其中 statusfeature 是：

func statusfeature(url string, token string) string {
    // Setup the request
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        log.Fatal(err)
    }
    req.Header.Set("Authorization", token)

    // Executing request
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return err.Error()
    }

    // Close response body as required
    defer resp.Body.Close()

    r := fmt.Sprintf("%d %s", resp.StatusCode, http.StatusText(resp.StatusCode))
    fmt.Printf("response:%s", r)

    return r
}

例如，如果我从原始 json 文件中删除特征名称 newa，现在我需要通过函数 apicall() 比较从服务器提取的信息json 中并通过函数 apiupdate()

问题是我正在努力比较从 json 中的服务器提取的信息和我用来更新服务器当前信息的 json 文件。这里是否需要使用 json.unmarshal() 进行比较？

如何将现有 json 文件与从服务器提取的 json 信息进行比较，以做出相应的更改？我想在修改原始 json 文件时在新函数中进行比较，以便我可以更新服务器的信息。

我可以使用 golang 中的任何文档/示例吗？

正确答案

我仍然不完全确定你在寻找什么，但这里有一个关于如何解析 json 数据并逐步执行它的草图：

您可以将数据解析为嵌套的 map[string]interface{}，它更紧凑，但如果有很多字段，则使用起来会很烦人 - 您必须始终进行类型转换。 p>

或者，您可以声明表示 json 数据结构（至少是必需字段）的结构类型。您可以使用 https://mholt.github.io/json-to-go/ 等工具来避免手动工作。

package main

import (
    "encoding/json"
    "time"
)

type APIConfig struct {
    Environments []struct {
        Environment string `json:"environment"`
        Features    []struct {
            Name   string `json:"name"`
            Enable bool   `json:"enable"`
        } `json:"features"`
    } `json:"environments"`
}

type StatusFeature struct {
    Name         string   `json:"name"`
    Environments []string `json:"environments"`
    Features     []struct {
        Type         string      `json:"type"`
        Name         string      `json:"name"`
        CreatedAt    time.Time   `json:"createdAt"`
        LastSeenAt   interface{} `json:"lastSeenAt"`
        Stale        bool        `json:"stale"`
        Environments []struct {
            Name      string `json:"name"`
            Enabled   bool   `json:"enabled"`
            Type      string `json:"type"`
            SortOrder int    `json:"sortOrder"`
        } `json:"environments"`
    } `json:"features"`
    Members int `json:"members"`
    Version int `json:"version"`
}

func main() {
    fromConfigString := `{environments": [{"environment": "dev",---"...` // truncated for readability, your config
    var apiConfig APIConfig // we create an empty instance of APIConfig
    err := json.Unmarshal([]byte(fromConfigString), &apiConfig) // since you example seems to use strings, we need to convert them to byte slices
    if err != nil {
        panic(err)
    }

    statusFeatureString := `{"name":"Default","environments": ["dev","prod" ], ...` // truncated for readability, your server response
    var statusFeature StatusFeature // we create an empty instance of StatusFeature
    err = json.Unmarshal([]byte(statusFeatureString), &statusFeature)
    if err != nil {
        panic(err)
    }

    for _, fCE2 := range apiConfig.Environments {
        var found bool
        // it's probably nicer to extract the nested search loops into a separate method and just return true or false,
        // but I keep it here for the sake of compactness
    search:
        for _, fCF := range fCE2.Features {
            for _, fS := range statusFeature.Features {
                if fS.Name == fCF.Name {
                    found = true
                    break search
                }
            }
        }
        if found {
            // the feature from the config was found in the response. Do your stuff
        }
    }
}

终于介绍完啦！小伙伴们，这篇关于《在Go中比较从API调用中提取的JSON信息》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！