Golang manually implements json serialization through reflection

import (
	"encoding/json"
	"fmt"
	"testing"
)
type TestJson struct {
	UserId       int    `json:"user_id"` // Use the structure tag to specify the key name of the field in JSON	UserNickname string // If no tag is specified, the field name is used by default.	UserAge      int    `json:"age,omitempty"` // Use omitempty to ignore null values ​​during serialization}
func Test1(t *) {
	tJson1 := TestJson{1, "Jackson", 18}
	tJson2 := new(TestJson)
	jsonStr1, _ := (tJson1)
	jsonStr2, _ := (tJson2)
	(string(jsonStr1))
	(string(jsonStr2))
}

func Test2(t *) {
	tJson1 := TestJson{1, "Jackson", 18}
	jsonStr1, _ := (tJson1, "", "\t")
	(string(jsonStr1))
}

func Test3(t *) {
	jsonStr :=
		`{
			"user_id": 1,
			"UserNickname": "Jackson",
			"age": 18
		}`
	var tJson TestJson
	// Convert the string to a byte array and pass it into the parsed object pointer	// The second parameter must be a pointer to the target data type variable so that the function can modify the variable.	err := ([]byte(jsonStr), &tJson)
	if err != nil {
		("Parse error:", err)
	} else {
		(tJson)
	}
}

func Test5(t *) {
	jsonStr :=
		`{
			"user_id": 1,
			"UserNickname": "Jackson",
			"age": 18,
			"addr": ["Address 1","Address 2"],
			"info":{
				"id":"2",
				"name":"a"
			}
		}`
	var tJson TestJson
	err := ([]byte(jsonStr), &tJson)
	if err != nil {
		("Parse error:", err)
	} else {
		(tJson)
	}
}

func Test4(t *) {
	jsonStr :=
		`{
			"user_id": 1,
			"UserNickname": "Jackson",
			"age": 18,
			"addr": ["Address 1","Address 2"],
			"info":{
				"id":"2",
				"name":"a"
			}
		}`
	var tJson map[string]any
	err := ([]byte(jsonStr), &tJson)
	if err != nil {
		("Parse error:", err)
	} else {
		(tJson)
	}
}

func serializeSimple(data interface{}) string {
	var resultStr string = "{"
	//1. Reflected incoming structure	reflectDataValue := (data)
	reflectDataType := ()
	if () ==  {
		reflectDataValue = ()
	}
	if () ==  {
		reflectDataType = ()
	}
	//2. Get the field	for i := 0; i < (); i++ {
		field := (i)
		// Field name		var filedName = 
		// field value		filedValue := (i).Interface()
		//3. Determine the label of the field		if value, ok := ("json"); ok {
			// If there is a json tag, use the name of its definition			filedName = (value, ",omitempty", "")
			// Is it ignoring the empty value			if (value, "omitempty") {
				if filedValue == "" || filedValue == 0 {
					continue
				}
			}
		}
		// Stitching json		resultStr += ("\"%s\":\"%v\"", filedName, filedValue)
		resultStr += ","
	}
	//4. Splice string	resultStr += "}"
	// Remove the ending number	return (resultStr, ",}", "}")
}
func Test6(t *) {
	tJson1 := TestJson{1, "Jackson", 18}
	tJson2 := new(TestJson)
	jsonStr1, _ := (tJson1)
	jsonStr2, _ := (tJson2)
	(string(jsonStr1))
	(string(jsonStr2))
	("=========Custom implementation=========")
	(serializeSimple(tJson1))
	(serializeSimple(tJson2))
}

func parseSimple(str string, dataTemp interface{}) {
	// JSON format data to determine whether it is standard	if str != "" && str[0] == '{' && str[len(str)-1] == '}' {
		// Replace the {} before and after		str = ((str, "{", ""), "}", "")
		// After parsing the label of the structure, stuff it into the map alternate: map [field name] field address		structMap := map[string]{}
		// Get field name through reflection		rValue := (dataTemp)
		if () ==  {
			rValue = ()
		}
		rType := ()
		for i := 0; i < (); i++ {
			name := (i).Name
			// If there is a defined tag, use the field name of the tag			if lookup, ok := (i).("json"); ok {
				name = (lookup, ",omitempty", "")
			}
			// Map field names and values			structMap[name] = (i)
		}
		// According to, cut each key value pair		splitList := (str, ",")
		for i := range splitList {
			s := splitList[i]
			// According to: Cut out key and value			keyValue := (s, ":")
			key := keyValue[0]
			key = ((key), "\"", "") // Remove the spaces before and after			value := keyValue[1]
			value = ((value), "\"", "")
			// Push value back into the structure according to the key			switch structMap[key].Type().Kind() {
			// Pay attention to the type of judgment. Currently, only int and string are written, and other similar			case :
				intValue, _ := (value)
				structMap[key].SetInt(int64(intValue))
			case :
				structMap[key].SetString(value)
			default:
				panic("Data types not supported yet")
			}
		}
	}
}
func Test7(t *) {
	jsonStr :=
		`{
			"user_id": 1,
			"UserNickname": "Jackson",
			"age": 18
		}`
	var tJson1 TestJson
	var tJson2 TestJson
	err := ([]byte(jsonStr), &tJson1)
	if err != nil {
		("Parse error:", err)
	} else {
		(tJson1)
	}
	("=========Custom implementation=========")
	parseSimple(jsonStr, &tJson2)
	(tJson2)
}

func Test8(t *) {
	str := "123"
	// The second parameter is the cardinality, 10 means decimal	// The third parameter is the bit size, 0 means int64, 32 means int32, using 32 or 64 depends on your system architecture	num, err := (str, 10, 0)
	if err != nil {
		("Conversion error:", err)
	} else {
		("Conversion result:", num)
		// If you need int32, you can convert it like this		num32 := int32(num)
		("Convert to int32 result:", num32)
		// If you need int, you can convert it like this (note: on 32-bit systems this will be int32, on 64-bit systems this will be int64)		numInt := int(num)
		("Convert to int result:", numInt)
	}
}