json 和 结构体 转换

最新推荐文章于 2024-09-04 08:41:42 发布
最新推荐文章于 2024-09-04 08:41:42 发布
阅读量2.6k 收藏
点赞数
分类专栏： Go-Code
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ayqy42602/article/details/108132564
版权 
package main

import (
   "encoding/json"
   "fmt"
)

type User struct {
   Id int `json:"id"`
   Name string `json:"name"`
}

func main() {
   //将字符串解析为结构体的形式
   str := `{"id":1,"name":"yang"}`
   var user User
   //将字符串反解析为结构体
   json.Unmarshal([]byte(str),&user)
   fmt.Println(user)     //{1 yang}
   fmt.Printf("%T,%T\n",str,user)  //string,main.User
   //将结构体解析为字符串
   b,e := json.Marshal(user)
   fmt.Println(string(b),e)   //{"id":1,"name":"yang"} <nil>
   fmt.Printf("%T,%T\n",b,e)   //[]uint8,<nil>


   fmt.Printf("------------------------------\n")


   //将字符串反解析为字典
   var m map[string] interface{}
   json.Unmarshal([]byte(str),&m)
   fmt.Println(m)    //map[id:1 name:yang]
   fmt.Printf("%T,%T\n",str,m)   //string,map[string]interface {}
   //将字典解析为字符串
   b,e = json.Marshal(m)
   fmt.Println(string(b),e)   //{"id":1,"name":"yang"} <nil>
   fmt.Printf("%T,%T\n",b,e)  //[]uint8,<nil>

   fmt.Printf("-----------------------------\n")


   //将字符串反解析为数组
   s := `[1,2,3,4,5]`
   var a []int
   json.Unmarshal([]byte(s),&a)
   fmt.Println(a)       //[1 2 3 4 5]
   fmt.Printf("%T,%T\n",s,a)   //string,[]int
   //将数组解析为字符串
   b,e = json.Marshal(a)
   fmt.Println(string(b),e)  //[1,2,3,4,5] <nil>
   fmt.Printf("%T,%T\n",string(b),e)   //string,<nil>
}

将复杂的结构体解析为字符串

package main

import (
   "encoding/json"
   "fmt"
)

type ExploreCommercialCard struct {
   ModuleTitle string  `json:"moduleTitle"`
   SubTitle    string  `json:"subTitle"`
   Tag         string  `json:"tag"`
   Cards       []*Card `json:"cards"`
}

type Card struct {
   Type          uint8    `json:"type"`
   MainTitle     string   `json:"mainTitle"`
   SubTitle      string   `json:"subTitle"`
   TopCoverURL   string   `json:"topCoverUrl"`
   FullCoverURL  string   `json:"fullCoverUrl"`
   RightCoverURL string   `json:"rightCoverUrl"`
   Intro         string   `json:"intro"`
   Chapters      []string `json:"chapters"`
   BtnTitle      string   `json:"btnTitle"`
   *URL
}

type URL struct {
   TargetType  uint8  `json:"targetType"`
   TargetURL   string `json:"targetUrl"`
   TargetValue string `json:"targetValue"`
}

func main() {
   data := ExploreCommercialCard{
      ModuleTitle: "dafsd",
      SubTitle:    "afdsf",
      Tag: "xxxxx",
      Cards: []*Card{&Card{
         Type:          12,
         MainTitle:     "daf",
         SubTitle:      "fda",
         TopCoverURL:   "sdf",
         FullCoverURL:  "daf",
         RightCoverURL: "daf",
         Intro:         "dsaf",
         Chapters:      []string{"lj"},
         BtnTitle:      "da",
         URL: &URL{
            TargetURL: "dfda",
         },
      },
      },
   }

   fmt.Println(data)

// 解析为json格式是将结构体成员名称写位json的格式，输出
// 注意包含关系和继承关系的写法是不同的
// URL 和 Card 是继承关系 ，可以写在同一阶级上
// ExploreCommercialCard 和 Card 是包含关系，需要写在不同的阶级上
// 注意切片的写法
   str,err := json.Marshal(data)   
   fmt.Printf("%T ,%T\n",data,str)
   fmt.Println(string(str),err)
}

输出：

{dafsd afdsf xxxxx [0xc000078000]}
main.ExploreCommercialCard ,[]uint8
{"moduleTitle":"dafsd","subTitle":"afdsf","tag":"xxxxx","cards":[{"type":12,"mainTitle":"daf","subTitle":"fda","topCoverUrl":"sdf","fullCoverUrl":"daf","rightCoverUrl":"daf","intro":"dsaf","chapters":["lj"],"btnTitle":"da","targetType":0,"targetUrl":"dfda","targetValue":""}]}
 <nil>

test:

package aaa

type ExploreIcon struct {
	Icons []*Icon `json:"icons"`
}

type Icon struct {
	Style    uint8      `json:"style"`
	Contents []*Content `json:"content"`
}

type Content struct {
	CoverURL string `json:"coverUrl"`
	Title    string `json:"title"`
	SubTitle string `json:"subTitle"`
	*URL
}

------------------------------------------------------
package bbb

	resource := &aaa.ExploreIcon{
		Icons:[]*aaa.Icon{
			&aaa.Icon{
				Style:    1,
				Contents: []*aaa.Content{
					&aaa.Content{
						CoverURL: "http://coverurl",
						Title:    "title",
						SubTitle: "subtitle",
						URL:      &aaa.URL{
							TargetType:  3,
							TargetURL:   "http://exploreicon?param=$&&param2=$",
							TargetValue: "1,2",
						},
					},
					&aaa.Content{
						CoverURL: "http://coverurl2",
						Title:    "title2",
						SubTitle: "subtitle2",
						URL:      &aaa.URL{
							TargetType:  2,
							TargetURL:   "http://exporeicon2?param=$&&param2=$",
							TargetValue: "3,4",
						},
					},
				},
			},
		},
	}
---------------------------------------------------
取数据：   resource.Icons[0].Contents[1].URL.TargetURL

Demo:

package main

import (
	"encoding/json"
	"fmt"
	"reflect"
)
import _struct "github.com/golang/protobuf/ptypes/struct"

var goTypes = map[string]reflect.Type{
	"bool":                   reflect.TypeOf(false),
	"byte":                   reflect.TypeOf(byte(0)),
	"int":                    reflect.TypeOf(int(0)),
	"uint":                   reflect.TypeOf(uint(0)),
	"rune":                   reflect.TypeOf(rune(0)),
	"int8":                   reflect.TypeOf(int8(0)),
	"uint8":                  reflect.TypeOf(uint8(0)),
	"int16":                  reflect.TypeOf(int16(0)),
	"uint16":                 reflect.TypeOf(uint16(0)),
	"int32":                  reflect.TypeOf(int32(0)),
	"uint32":                 reflect.TypeOf(uint32(0)),
	"int64":                  reflect.TypeOf(int64(0)),
	"uint64":                 reflect.TypeOf(uint64(0)),
	"float32":                reflect.TypeOf(float32(0)),
	"float64":                reflect.TypeOf(float64(0)),
	"complex64":              reflect.TypeOf(complex64(0)),
	"complex128":             reflect.TypeOf(complex128(0)),
	"string":                 reflect.TypeOf(string("")),
	"[]byte":                 reflect.TypeOf([]byte("")),
	"google.protobuf.Struct": reflect.PtrTo(reflect.TypeOf(_struct.Struct{})),
}


func IsBuiltInType(goType string) (find bool) {
	_, find = goTypes[goType]
	return find
}

type ServiceDefinition struct {
	Version       int64                    `json:"version"`
	TypeConfigs   map[string]*TypeConfig   `json:"type_configs"`
	MethodConfigs map[string]*MethodConfig `json:"method_configs"`
}

type TypeConfig struct {
	FieldConfigs []*FieldConfig `json:"field_configs"`
}

type FieldConfig struct {
	Name string `json:"name"`
	Type string `json:"type"`
	Tag  string `json:"tag"`
}

type MethodConfig struct {
	Path        string             `json:"path"`
	TypeConfigs *MethodTypeConfigs `json:"type_configs"`
}

type MethodTypeConfigs struct {
	ReqType  string `json:"req_type"`
	RespType string `json:"resp_type"`
}

func main() {
	/*data := `{
    "version": 0,
    "type_configs": {
        "SamplePayload": {
            "field_configs": [
                {
                    "name": "Version",
                    "type": "int32",
                    "tag": "protobuf:\"varint,1,opt,name=version,json=version,proto3\" json:\"version,omitempty\""
                },
                {
                    "name": "Data",
                    "type": "[]byte",
                    "tag": "protobuf:\"bytes,2,opt,name=data,json=data,proto3\" json:\"data,omitempty\""
                }
            ]
        },
        "SampleReply": {
            "field_configs": [
                {
                    "name": "Ack",
                    "type": "int64",
                    "tag": "protobuf:\"varint,1,opt,name=ack,json=ack,proto3\" json:\"ack,omitempty\""
                },
                {
                    "name": "Payload",
                    "type": "SamplePayload",
                    "tag": "protobuf:\"bytes,2,opt,name=payload,json=payload,proto3\" json:\"payload,omitempty\""
                }
            ]
        },
        "SampleRequest": {
            "field_configs": [
                {
                    "name": "Syn",
                    "type": "int64",
                    "tag": "protobuf:\"varint,1,opt,name=syn,json=syn,proto3\" json:\"syn,omitempty\""
                },
                {
                    "name": "Payload",
                    "type": "SamplePayload",
                    "tag": "protobuf:\"bytes,2,opt,name=payload,json=payload,proto3\" json:\"payload,omitempty\""
                }
            ]
        }
    },
    "method_configs": {
        "SampleMethod": {
            "path": "/your.package.SampleService/SampleMethod",
            "type_configs": {
                "req_type": "SampleRequest",
                "resp_type": "SampleReply"
            }
        }
    }
}
`*/
	serviceDefinition := ServiceDefinition{
		Version: 0,
		TypeConfigs: map[string]*TypeConfig{
			"Sample": {
				FieldConfigs: []*FieldConfig{{
					Name: "aaa",
					Type: "a01",
					Tag: "001",
				 },
				{
					Name: "bbb",
					Type: "b01",
					Tag: "002",
				},
				},
			},
			"SampleReply":{
				FieldConfigs: []*FieldConfig{
					{
						Name: "ccc",
						Type: "c01",
						Tag: "003",
					},
				},
			},
			"SampleRequst":{
				FieldConfigs: []*FieldConfig{
					{
						Name: "ddd",
						Type: "d01",
						Tag: "004",
					},
				},
			},
		},
		MethodConfigs: map[string]*MethodConfig{
			"SampleMethod":{
				Path: "xxxxxxx",
				TypeConfigs: &MethodTypeConfigs{
					RespType: "abc",
					ReqType: "abcd",
				},
			},
		},
	}

	str,err := json.Marshal(serviceDefinition)
	fmt.Println(string(str))
	fmt.Println(err)
	/*err := json.Unmarshal([]byte(data),serviceDefinition)
	if err != nil {
		fmt.Println("err")
	}
	fmt.Println(serviceDefinition)*/

	fmt.Println("-------------------------")

	for typeName,typeConfig := range serviceDefinition.TypeConfigs {
		fmt.Printf("1: %T, %v, %T, %v\n",typeName,typeName,typeConfig,typeConfig)
		for fieldName,fieldConfig := range typeConfig.FieldConfigs {
			fmt.Printf("2: %T, %v, %T, %v\n",fieldName,fieldName,fieldConfig,fieldConfig)
			fieldType := fieldConfig.Type
			fmt.Printf("3: %T,%v\n",fieldType,fieldType)
			if find := IsBuiltInType(fieldType); find {
				fmt.Printf("4: %T,%v\n",find,find)
			}
		}
	}
	fmt.Println("-------------------------")

	fmt.Println(goTypes)
	
	fmt.Printf("%T,%d\n",goTypes,len(goTypes))
	for key,val := range goTypes {
		fmt.Println(key," ---> ",val)
	}
}

输出：

{"version":0,"type_configs":{"Sample":{"field_configs":[{"name":"aaa","type":"a01","tag":"001"},{"name":"bbb","type":"b01","tag":"002"}]},"SampleReply":{"field_configs":[{"name":"ccc","type":"c01","tag":"003"}]},"SampleRequst":{"field_configs":[{"name":"ddd","type":"d01","tag":"004"}]}},"method_configs":{"SampleMethod":{"path":"xxxxxxx","type_configs":{"req_type":"abcd","resp_type":"abc"}}}}
<nil>
-------------------------
1: string, SampleReply, *main.TypeConfig, &{[0xc000060870]}
2: int, 0, *main.FieldConfig, &{ccc c01 003}
3: string,c01
1: string, SampleRequst, *main.TypeConfig, &{[0xc0000608a0]}
2: int, 0, *main.FieldConfig, &{ddd d01 004}
3: string,d01
1: string, Sample, *main.TypeConfig, &{[0xc000060810 0xc000060840]}
2: int, 0, *main.FieldConfig, &{aaa a01 001}
3: string,a01
2: int, 1, *main.FieldConfig, &{bbb b01 002}
3: string,b01

-------------------------
map[[]byte:[]uint8 bool:bool byte:uint8 complex128:complex128 complex64:complex64 float32:float32 float64:float64 google.protobuf.Struct:*structpb.Struct int:int int16:int16 int32:int32 int64:int64 int8:int8 rune:int32 string:string uint:uint uint16:uint16 uint32:uint32 uint64:uint64 uint8:uint8]


map[string]reflect.Type,     20

uint64  --->  uint64
complex128  --->  complex128
[]byte  --->  []uint8
int8  --->  int8
int16  --->  int16
uint16  --->  uint16
float32  --->  float32
uint  --->  uint
uint32  --->  uint32
int64  --->  int64
float64  --->  float64
complex64  --->  complex64
uint8  --->  uint8
byte  --->  uint8
int  --->  int
rune  --->  int32
int32  --->  int32
string  --->  string
google.protobuf.Struct  --->  *structpb.Struct
bool  --->  bool
y果子
关注
专栏目录
quicktype-vscode：VS Code扩展，可将JSON转换为TypeScript，C＃，Go等
01-30
支持TypeScript ， Python ， Go ， Ruby ， C# ， Java ， Swift ， Rust ， Kotlin ， C++ ， Flow ， Objective-C ， JavaScript ， Elm和JSON Schema 。 从JSON，JSON Schema和TypeScript交互式生成类型和（反序列化）代码 将JSON / JSON Schema / TypeScript粘贴为代码 quicktype从样本JSON数据中推断类型，然后输出强类型化的模型和序列化程序，以便以所需的编程语言来处理该数据。 有关更多说明，请阅读 。 在任何JSON文件中，请使用命令“为JSON打开quicktype”来调用quicktype，它将根据JSON生成类型。 调用“更改quicktype的目标语言”以选择其他语言。 JSON Schema和TypeScript有类似的“ Open quicktype”命令。 使用quicktype的另一种方法是将JSON复制到剪贴板中，并调用“将JSON作为代码/类型粘贴”： 要获得更强大的体验，包括自定义选项和从多
Go：Json转结构体
ttropsstack的博客
10-18 2311
请求Zabbix API，通过itemid获取到AppName（应用集名称）
JSON格式化？超简单！
最新发布
weixin_44904675的博客
09-04 956
这些工具通常提供将原始JSON字符串转换为缩进和换行符分隔的格式化字符串的功能，以便更清晰地查看其结构。JSON格式化是指将JSON（JavaScript Object Notation）数据转换成一种更易读、结构化的格式。JSON是一种轻量级的数据交换格式，它基于JavaScript的一个子集，易于人阅读和编写，同时也易于机器解析和生成。这将在当前目录下创建一个名为"data.json"的文件，并将格式化的json数据写入其中。输出结果将是一个格式化的json字符串，具有缩进和换行。
cJSON如何转化为结构体
最后一个bug的博客
03-22 932
例如，可以使用cJSON_Parse函数解析JSON数据，并使用cJSON_GetObjectItem函数获取JSON数据中的键值对，然后将其转换为C语言结构体。cjson是一个用于解析和生成JSON数据的C语言库，它提供了一些API函数来操作JSON数据。【最后一个bug】多平台都有更新和发布，大家可以一键三连，关注+星标，不错过精彩内容~例如，可以将C语言结构体中的数据存储到数据库中，或者将其转换为其他格式的数据。
vscode的json设置
weixin_45781661的博客
05-15 1495
vscode的设置 在vscode设置转换成json格式的形式 然后在如下代码复制粘贴进去 { "eslint.autoFixOnSave": true, "eslint.validate": [ "javascript", // 用eslint的规则检测js文件 { "language": "vue", // 检测vue文件 "autoFix": true // 为vue文件开启保存自动修复的功能 }, { "lan
python脚本将json文件生成C语言结构体
weixin_44708624的博客
09-08 1161
1.引言 以前用过python脚本根据excel生成相关C语言代码，其实本质就是文件的读写，主要是逻辑问题，这次尝试将json文件生成C语言的结构体。 2.代码 这是一个json文件，生成这个结构体的本质是深度优先遍历，为了适应最复杂的情况，随便写了一个json文件(大家也可以根据需求自己改，我是自己写的，成功之后就去生产随机json的网站测试，目前没有啥问题，如果大家可以发现问题欢迎指出，在此...
结构体转为JSON文本
10-17
QT框架提供了一个强大的JSON支持库，名为`QJsonDocument`和`QJsonObject`，它们可以帮助我们将C++中的结构体转换成JSON格式，反之亦然。这个过程不仅可以提高开发效率，还能够确保数据在不同系统间的一致性。 首先...
C++结构体和json/xml之间互相转换
02-09
在C++中将结构体转换为JSON或XML，我们需要定义一个映射规则，将结构体的每个成员对应到JSON或XML的键值。这通常涉及到反射(reflection)的概念，即程序能够自我检查其结构。由于C++标准库不直接支持反射，我们通常...
go语言使用第三方包 json化结构体操作示例
09-19
为了方便使用，我们可以为`NewsModel`结构体添加一个名为`ToJson`的方法，这样就可以直接调用该方法将结构体转换为JSON字符串： ```go package main import ( "fmt" "github.com/pquerna/ffjson/ffjson" ) type...
实现C语言json和结构体之间的相互转换.zip
03-16
可以在这些基础上学习借鉴进行修改和扩展，实现其它功能。可下载学习借鉴，你会有所收获。 项目资源具有较高的学习借鉴价值，也可直接拿来修改复现。可以在这些基础上学习借鉴进行修改和扩展，实现其它功能。可下载...
在json字符串和c++对象之间进行转换。json字符串和c++结构体之间互相转换- xyz347 / x2struct
01-27
项目“x2struct”包含的主要功能是解析JSON字符串并将其内容映射到C++的结构体中，同时也可以将C++结构体转换回JSON字符串。这个过程通常被称为序列化和反序列化。序列化是将C++对象的状态转换为可存储或可传输的...
json与C++结构体互相转换
热门推荐
xyz347的博客
02-19 2万+
代码github地址 用于在C++结构体和json/xml/json/libconfig之间互相转换 json/xml只需要头文件, 无需编译库文件 json缺省支持，其他的需要修改config.h开启相应功能 以下例子全部以json为例，其他的类似，具体可以参考x2struct.hpp里面x2struct::X的api定义 目录 基本用法 必需节点 别名 继承 位...
Go Json 和 结构体互相转换
HeroRazor的专栏
04-25 794
【代码】Go Json 和 结构体互相转换。
C语言实现Json与结构体相互转换——cson
s448573057的博客
12-26 2万+
写在最前面，不擅长写文档和博客，自惭行文拖沓，不爱看的直接移步：https://github.com/sunchb/cson.git 目录前言实现1.实现“反射”1.1.描述结构体属性1.2.访问结构体属性1.3.结构体属性赋值1.3.数组和结构体类型的描述2.序列化3.反序列化代码及Demo 前言 之前用C语言解析过json，虽然借助jansson这样强大的解析库，可以将字符串转化为json对象...
Delphi10.3通过REST单元使类和JSON数据互相转换
qq_18932003的博客
03-21 821
一、我们定义一个简单的类 TPeople = class private FName: string; FScore: Integer; FAge: TDateTime; public property Name: string read FName write FName; property Score: Integer read FS...
Golang struct、json、map互相转化
Z451835239的博客
08-23 550
第三方接口返回json 你是怎么处理的？： { "resp": { "respCode": "0", "respMsg": "ok", "app": { "userId": "d12abd3da59d47e6bf13893ec43730b8" } } } 使用结构体结构体拆解 go 内置了json字串的解析包 “encoding/json” 按照json库的分析，其实每一个花括号就是一个结构体 &g
【delphi】 JSON 操作详解（TJSONObject）
sensor_WU 博客
06-22 8034
Delphi官方提供的对于JSON操作的单元是：system.JSON，delphi将JSON元素都定义为对象，注意是对象，既然是对象就需要创建，需要释放。具体如下： Delphi JSON 常用对象 编号 对象 说明 1 TJSONValue 所有JSON类的祖先，包括以下锁有对象 2 TJSONObject 一个JSON对象，对应一段JSON字符串 3 TJSONPair 代表一个Key-Value的JSON对，包括josnString和j
json数据转换成结构体
开发之路
12-21 2455
package main import ( "encoding/json" "fmt" ) type IT1 struct { Company string `json:"company"` Subjects []string `json:"subjects"` IsOk bool `json:"isok"` Price float64 `j...
Go json转struct工具
Martian
03-01 2708
一个很好用的工具集合的web页面，包含常用的json、base64、url、hash、加密等，最重要的是页面简洁干净。 名称为OKTools，地址如下： https://oktools.net/json2go 这里说一下个人比较喜欢的一个工具，go语言的json转struct，当然我们也可以自己写一个，不过还是不要重复造轮子了。 https://oktools.net/json2go 例证说明 json 格式化json工具，https://www.json.cn/ 非常好用，不过是有广告的 .
在QT中 如何实现json和结构体的互相转换
06-13
首先，您需要将结构体转换为QJsonObject对象。您可以通过在QJsonObject对象中创建键值对来实现此目的。例如，假设您有一个名为Person的结构体，其中包含name和age属性： ```cpp struct Person { QString name; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值