草庐IT

go - go 中具有依赖条件的动态数据结构(嵌套 json)

coder 2024-07-13 原文

<分区>

我正在尝试在 go 中创建动态嵌套的 json。我知道 go 是静态类型，有多种方法可以创建动态对象(接口(interface))，我想知道是否有办法解决我在嵌套 json 中的依赖映射

样本 json

 [
{
  "display" : "Environment" ,
  "field" : "test_env" ,
  "value" : {
  "display" : "staging",
  "value" : "s"
},
   "type" : "drop-down" ,
   "data" : [
    {
      "display" : "version" ,
      "field" : "test_version" ,
      "value" : {
       "display" : "1.1.9" ,
        "value" : "1.1.9"
      },
      "type" : "drop-down" ,
      "data" : [
        {
          "display" : "DataCenter" ,
          "field" : "test_dc" ,
          "value" : {
           "display" : "washington",
           "value" : "wa"
         },
          "type" : "drop-down" ,
         "data" : [{
         "display" : "Secondary" ,
         "field" : "test_secondary_dc" ,
         "value" : {
             "display" : "miami" ,
             "value" : "mi"
           },
            "type" : "drop-down" ,
            "data" : [{
              "display" : "Size" ,
              "field" : "test_size" ,
              "value" : {
                "display" : "small" ,
                "value" : "s"
                  }
              }]
            }]
        }
      ]
     }
   ]
 },
 {
  "display" : "Environment" ,
  "field" : "test_env" ,
  "value" : {
    "display" : "production",
    "value" : "p"
  },
  "type" : "drop-down" ,
  "data" : [
    {
      "display" : "version" ,
      "field" : "test_version" ,
      "value" : {
        "display" : "1.1.9" ,
        "value" : "1.1.9"
       },
      "type" : "drop-down" ,
      "data" : [
         {
          "display" : "DataCenter" ,
          "field" : "test_dc" ,
          "value" : {
            "display" : "miami",
            "value" : "mi"
          },
          "type" : "drop-down" ,
          "data" : [{
            "display" : "Secondary" ,
            "field" : "test_secondary_dc" ,
            "value" : {
              "display" : "washington" ,
              "value" : "wa"
            },
            "type" : "drop-down" ,
            "data" : [{
              "display" : "Size" ,
              "field" : "test_size" ,
              "value" : {
                "display" : "medium" ,
                "value" : "m"
             }
              }]
            }]
        }
      ]
    }
  ]
}
]

示例代码:

package main

import (
    "fmt"
     "reflect"
 )


    // struct definition ///

   type  RootElem struct {
        RDisplay string `json:"display"`
        RField string `json:"field"`
        RType string `json:"type"`
        RData RSlice `json:"data"`
        RValue RValue `json:"value"`
        }

type RValue struct {
    Display string `json:"display"`
    Evalue string `json:"value"`
    }

type Vars struct {
    Env      string `json:"environment"`
    Version  string `json:"version"`
    Zone     string `json:"zone"`
    PDcenter string `json:"primary_dc"`
    SDcenter string `json:"secondary_dc,omitempty"`
    Size     string `json:"size"`
  }

type RSlice []RootElem

func valueFactory(etype, evalue string) string {
  switch (etype) {
    case "ENVIRONMENT":
      return environmentValue(evalue);
    case "VERSION":
      return versionValue(evalue);
    case "ZONE":
      return zoneValue(evalue);
    case "PRIMARYDC":
      return primaryValue(evalue);
    case "SECONDARYDC":
      return secondaryValue(evalue);
    case "SIZE":
      return sizeValue(evalue);
    default:
      return("Specifying a type we don't have.");
   }
  }

func sizeValue(sz string) string {
   switch (sz) {
     case "Small":
      return "s"
     case "Medium":
      return "m"
     case "Large" :
       return "l"
     default:
       return "This is not a size environment value"
    }
}


func environmentValue(env string) string {
  switch (env) {
    case "Production":
      return "p"
    case "staging":
      return "s"
    default:
      return "This is not a valid environment value"
  }
}

func versionValue(ver string) string {
  switch (ver) {
     case "1.1.9":
       return "1.1.9"
     default:
      return "This is not a valid version value"
  }
 }

 func zoneValue(zone string) string {
  switch (zone) {
    case "BLACK":
     return "Black"
    case "GREEN" :
      return "Green"
   default:
     return "This is not a valid zone value"
  }
}

  func primaryValue(pdc string) string {
  switch (pdc) {
     case "washington ":
       return "wa"
    case "Miami" :
       return "mi"

     default:
       return "This is not a valid primary data center value"
  }
 }

 func secondaryValue(sdc string) string {
  switch (sdc) {
   case "washington":
     return "wa"
    case "Miami" :
      return "mi"
    default:
      return "This is not a valid secondary data center value"
 }
}


func dataGeneric(display, field, etype string) (relm RootElem) {
 relm.RDisplay =  display
     relm.RField = field
     relm.RValue.Display =  ""
 relm.RValue.Evalue =  ""
     relm.RType = etype
     return  relm
 }

 func dataEnvironment() RootElem {
   display := "Environment"
   field := "test_env"
   etype := "dropdown"
   return dataGeneric(display, field, etype)
}

func dataVersion() RootElem {
  display := "Version"
  field := "test_version"
  etype := "dropdown"
  return dataGeneric(display, field, etype)
 }

func dataZone() RootElem {
  display := "Zone"
  field := "test_zone"
  etype := "dropdown"
  return dataGeneric(display, field, etype)
}

func dataPrimary() RootElem {
 display := "Primary Data Center"
 field := "test_dc"
 etype := "dropdown"
 return dataGeneric(display, field, etype)
}

func dataSecondary() RootElem {
  display := "Secondary Data Center"
  field := "test_secondary_dc"
  etype := "dropdown"
  return dataGeneric(display, field, etype)
}

func dataSize() RootElem {
  display := "size"
  field := "test_size"
  etype := "dropdown"
   return dataGeneric(display, field, etype)
}


func dataFactory(etype string) RootElem {

 var rem RootElem
  switch (etype) {
     case "ENVIRONMENT":
      return dataEnvironment()
    case "VERSION":
      return dataVersion()
    case "ZONE":
      return dataZone()
    case "PRIMARYDC":
      return dataPrimary()
    case "SECONDARYDC":
      return dataSecondary()
    case "SIZE":
      return dataSize()
  }
   return rem
}




func main() {

 // sample element ///
var elment = Vars{
    Env: "Production" ,
    Version: "1.1.9" ,
    Zone: "GREEN" ,
    PDcenter: "Washington" ,
    SDcenter: "Miami" ,
    Size: "Small" ,
    }


var Dict = []string{"ENVIRONMENT" , "VERSION" , "ZONE" , "PRIMARYDC" , "SECONDARYDC" , "SIZE" }


var newData, finalElem RootElem
for i := 0 ; i < reflect.ValueOf(elment).NumField() ; i++ {
    currentElement := reflect.ValueOf(elment).Field(i).Interface()
    currentElemType := Dict[i]

    newData = dataFactory(currentElemType)
    newData.RValue.Display = currentElement.(string)
    newData.RValue.Evalue = valueFactory(currentElemType, currentElement.(string))

    if finalElem.RDisplay == "" {
        finalElem = newData
    } else {
            if len(finalElem.RData) == 0 {
         finalElem.RData = append(finalElem.RData, newData)
            } else {
                if len(finalElem.RData[0].RData) == 0 {
                 finalElem.RData[0].RData = append( finalElem.RData[0].RData , newData)
                } else {
                    if len(finalElem.RData[0].RData[0].RData) == 0 {
                    finalElem.RData[0].RData[0].RData = append (finalElem.RData[0].RData[0].RData , newData)
                    } else {
                        if len(finalElem.RData[0].RData[0].RData[0].RData) == 0 {
                        finalElem.RData[0].RData[0].RData[0].RData = append(finalElem.RData[0].RData[0].RData[0].RData, newData )
                        } else {
                            finalElem.RData[0].RData[0].RData[0].RData[0].RData = append(finalElem.RData[0].RData[0].RData[0].RData[0].RData, newData)
                            }
                        }
                    }
                }
        }
}

 fmt.Println("final element" , finalElem)

}

想知道是否有一种方法可以编写用于在 go 中创建动态嵌套 json 的递归函数？

谢谢

gojson34displayreturn

有关go - go 中具有依赖条件的动态数据结构(嵌套 json)的更多相关文章

  1. ruby - 具有身份验证的私有(private) Ruby Gem 服务器 - 2

    我想安装一个带有一些身份验证的私有(private)Rubygem服务器。我希望能够使用公共(public)Ubuntu服务器托管内部gem。我读到了http://docs.rubygems.org/read/chapter/18.但是那个没有身份验证-如我所见。然后我读到了https://github.com/cwninja/geminabox.但是当我使用基本身份验证(他们在他们的Wiki中有)时，它会提示从我的服务器获取源。所以。如何制作带有身份验证的私有(private)Rubygem服务器？这是不可能的吗？谢谢。编辑:Geminabox问题。我尝试“捆绑”以安装新的gem..

  2. ruby-on-rails - Rails 编辑表单不显示嵌套项 - 2

    我得到了一个包含嵌套链接的表单。编辑时链接字段为空的问题。这是我的表格:Editingkategori{:action=>'update',:id=>@konkurrancer.id})do|f|%>'Trackingurl',:style=>'width:500;'%>'Editkonkurrence'%>|我的konkurrencer模型:has_one:link我的链接模型:classLink我的konkurrancer编辑操作:defedit@konkurrancer=Konkurrancer.find(params[:id])@konkurrancer.link_attrib

  3. ruby - 解析 RDFa、微数据等的最佳方式是什么，使用统一的模式/词汇(例如 schema.org)存储和显示信息 - 2

    我主要使用Ruby来执行此操作，但到目前为止我的攻击计划如下:使用gemsrdf、rdf-rdfa和rdf-microdata或mida来解析给定任何URI的数据。我认为最好映射到像schema.org这样的统一模式，例如使用这个yaml文件，它试图描述数据词汇表和opengraph到schema.org之间的转换:#SchemaXtoschema.orgconversion#data-vocabularyDV:name:namestreet-address:streetAddressregion:addressRegionlocality:addressLocalityphoto:i

  4. ruby - 将散列转换为嵌套散列 - 2

    这道题是thisquestion的逆题.给定一个散列，每个键都有一个数组，例如{[:a,:b,:c]=>1,[:a,:b,:d]=>2,[:a,:e]=>3,[:f]=>4,}将其转换为嵌套哈希的最佳方法是什么{:a=>{:b=>{:c=>1,:d=>2},:e=>3,},:f=>4,} 最佳答案 这是一个迭代的解决方案，递归的解决方案留给读者作为练习:defconvert(h={})ret={}h.eachdo|k,v|node=retk[0..-2].each{|x|node[x]||={};node=node[x]}node[

  5. ruby-on-rails - Rails HTML 请求渲染 JSON - 2

    在我的Controller中，我通过以下方式在我的index方法中支持HTML和JSON:respond_todo|format|format.htmlformat.json{renderjson:@user}end在浏览器中拉起它时，它会自然地以HTML呈现。但是，当我对/user资源进行内容类型为application/json的curl调用时(因为它是索引方法)，我仍然将HTML作为响应。如何获取JSON作为响应？我还需要说明什么？ 最佳答案 您应该将.json附加到请求的url，提供的格式在routes.rb的路径中定义。这

  6. ruby-on-rails - 在 ruby​​ .gemspec 文件中，如何指定依赖项的多个版本？ - 2

    我正在尝试修改当前依赖于定义为activeresource的gem:s.add_dependency"activeresource","~>3.0"为了让gem与Rails4一起工作，我需要扩展依赖关系以与activeresource的版本3或4一起工作。我不想简单地添加以下内容，因为它可能会在以后引起问题:s.add_dependency"activeresource",">=3.0"有没有办法指定可接受版本的列表？~>3.0还是~>4.0？ 最佳答案 根据thedocumentation,如果你想要3到4之间的所有版本，你可以这

  7. ruby - RuntimeError(自动加载常量 Apps 多线程时检测到循环依赖 - 2

    我收到这个错误:RuntimeError(自动加载常量Apps时检测到循环依赖当我使用多线程时。下面是我的代码。为什么会这样？我尝试多线程的原因是因为我正在编写一个HTML抓取应用程序。对Nokogiri::HTML(open())的调用是一个同步阻塞调用，需要1秒才能返回，我有100,000多个页面要访问，所以我试图运行多个线程来解决这个问题。有更好的方法吗？classToolsController0)app.website=array.join(',')putsapp.websiteelseapp.website="NONE"endapp.saveapps=Apps.order("

  8. ruby - 如何根据特征实现 FactoryGirl 的条件行为 - 2

    我有一个用户工厂。我希望默认情况下确认用户。但是鉴于unconfirmed特征，我不希望它们被确认。虽然我有一个基于实现细节而不是抽象的工作实现，但我想知道如何正确地做到这一点。factory:userdoafter(:create)do|user,evaluator|#unwantedimplementationdetailshereunlessFactoryGirl.factories[:user].defined_traits.map(&:name).include?(:unconfirmed)user.confirm!endendtrait:unconfirmeddoenden

  9. ruby - 在 Ruby 中有条件地定义函数 - 2

    我有一些代码在几个不同的位置之一运行:作为具有调试输出的命令行工具，作为不接受任何输出的更大程序的一部分，以及在Rails环境中。有时我需要根据代码的位置对代码进行细微的更改，我意识到以下样式似乎可行:print"Testingnestedfunctionsdefined\n"CLI=trueifCLIdeftest_printprint"CommandLineVersion\n"endelsedeftest_printprint"ReleaseVersion\n"endendtest_print()这导致:TestingnestedfunctionsdefinedCommandLin

  10. ruby - 定义方法参数的条件 - 2

    我有一个只接受一个参数的方法:defmy_method(number)end如果使用number调用方法，我该如何引发错误？？通常，我如何定义方法参数的条件？比如我想在调用的时候报错:my_method(1) 最佳答案 您可以添加guard在函数的开头，如果参数无效则引发异常。例如:defmy_method(number)failArgumentError,"Inputshouldbegreaterthanorequalto2"ifnumbereputse.messageend#=>Inputshouldbegreaterthano

随机推荐