Use tag tag in golang structure

stay Golang Used in structures tag label

brief introduction

We can follow the field of the structure , Add some descriptions of this field （ Meta information meta）, The program parses this information through reflection and uses .

Grammatical structure

// Notice that there are backquotes outside 
`key:"value" key:"value"`

• In reverse quotation marks ,key No double quotes ,value quotation marks , Multiple values are separated by spaces

package main

import (
	"fmt"
	"reflect"
)

func main() {
    
	type S struct {
    
		F string `species:"gopher" color:"blue"`
	}
	// Instantiate structure , It is not used here , So null instantiation 
	s := S{
    }
	// Use reflection to get the type type 
	st := reflect.TypeOf(s)
	// Get the first field 
	field := st.Field(0)
	// Get tag What's inside 
	fmt.Println(field.Tag.Get("color"), field.Tag.Get("species"))
}

a key ：

• know tag How to write the grammatical structure of labels

Running results

blue gopher

application json code

• Through the code

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"os"
	"time"
)

// Generally, our field names are capitalized , But we json It's all lowercase , You can go through here tag To use lowercase to know uppercase fields 
type User struct {
    
	Name      string    `json:"name"`
	Password  string    `json:"password"`
	CreatedAt time.Time `json:"createdAt"`
}

func main() {
    
	u := &User{
    
		Name:      "Crisp",
		Password:  "123456",
		CreatedAt: time.Now(),
	}

	out, err := json.MarshalIndent(u, "", " ")
	if err != nil {
    
		log.Println(err)
		os.Exit(1)
	}
	fmt.Println(string(out))
}

Running results

• Generated json The format is based on json To express

{
    
        "name": "Crisp",
        "password": "123456",
        "createdAt": "2022-07-21T15:59:36.200572+08:00"
}

application xml code

package main

import (
	"encoding/xml"
	"fmt"
	"os"
)

func main() {
    
	type Address struct {
    
		City, State string
	}
	type Person struct {
    
		XMLName   xml.Name `xml:"person"`
		Id        int      `xml:"id,attr"`  //attr Representative attribute 
		FirstName string   `xml:"name>first"`
		LastName  string   `xml:"name>last"`  //> Child node 
		Age       int      `xml:"age"`
		Height    float32  `xml:"height,omitempty"`
		Married   bool
		Address
		Comment string `xml:"comment"`
	}
	v := &Person{
    Id: 13, FirstName: "C", LastName: "risp", Age: 18}
	v.Comment = " notes ."
	v.Address = Address{
    " Beijing ", " haidian "}
	output, err := xml.MarshalIndent(v, "", " ")
	if err != nil {
    
		fmt.Printf("error:%v\n", err)
	}
	_, err = os.Stdout.Write(output)
	if err != nil {
    
		return
	}
}

Running results

<person id="13">
        <name>
                <first>C</first>
                <last>risp</last>
        </name>
        <age>18</age>
        <Married>false</Married>
        <City> Beijing </City>
        <State> haidian </State>
        <comment> notes .</comment>
</person>

application form Form binding ,gorm

• Can write multiple tag label , Use spaces to separate

type Channel struct {
    
	Id      uint64 `form:"id" gorm:"primaryKey"`
	Title   string `form:"title" gorm:"title"`
	Slug    string `form:"slug" gorm:"slug"`
	Content string `form:"content" gorm:"content"`
	Status  int    `form:"status" gorm:"status"`
	Weight  int    `form:"weight" gorm:"weight"`
}

gin frame form And data binding

package main

import "C"
import (
	"github.com/gin-gonic/gin"
	"net/http"
)

type Login struct {
    
  //form： In the form name Usually lowercase id,json： The parameters returned to the front end by separating the front end from the front end ,binding： Field validation 
	User     string `form:"user" json:"user" binding:"required"`
	Password string `form:"password" json:"password" binding:"required"`
}

func main() {
    
	router := gin.Default()

	//  binding  JSON ({"user":"manu","password":"123"})
	router.POST("/loginJSON", func(c *gin.Context) {
    
		var json Login
		if err := c.ShouldBindJSON(&json); err == nil {
    
			if json.User == "manu" && json.Password == "123" {
    
				c.JSON(http.StatusOK, gin.H{
    "status": " Successfully logged in "})
			} else {
    
				c.JSON(http.StatusUnauthorized, gin.H{
    "status": " unauthorized "})
			}
		} else {
    
			C.JSON(http.StatusBadRequest, gin.H{
    "error": err.Error()})
		}
	})

	//HTML form (user=manu&password=123)
	router.POST("/loginForm", func(c *gin.Context) {
    
		var form Login
		if err := c.ShouldBind(&form); err == nil {
    
			if form.User == "manu" && form.Password == "123" {
    
				c.JSON(http.StatusOK, gin.H{
    "status": " Successfully logged in "})
			} else {
    
				c.JSON(http.StatusUnauthorized, gin.H{
    "status": " unauthorized "})
			}
		} else {
    
			C.JSON(http.StatusBadRequest, gin.H{
    "error": err.Error})
		}
	})
}

More applications

• json- from encoding/json package Use , For details, see json.Marshal()
• xml- from encoding/xml Package usage , For details, see xml.Marshal()
• bson- from gobson Use , The details are in bson.Marshal(); Also by mongo-go The driver , stay bson package doct It's detailed in
• protobuf-github.com/golang/protobuf/proto Users , The document details
• yaml- from gopkg.in/yaml.v2 Package usage , For details, see yaml.Marshal()
• db- By github.com/jmoiron/sqlx Package usage ; Also by github.com/go-gorp/gorp Package usage
• orm- from github.com/astaxie/beego/orm Package usage , See Models-Beego ORM
• gorm- Use gorm.io/gorm, Examples can be found in their documentation
• valid- from github.com/asaskevich/govalidator Package usage , Examples can be found in the project page
• datastore- from appengine/datastore(Google App Engine platform 、Datastore service ) Use , See properties for details
• schema- be used for github.com/gorilla/schema fill struct HTML Form value , There are detailed instructions in the package document
• asn- from encoding/asn1 Package usage , The details are in asn1.Marshal() and asn1.Unmarshal()
• csv- By github.com/gocarina/gocsv Package usage
• env- By github.com/caarlos0/env Package usage