À quoi servent les balises dans Go?

Dans la spécification de langue Go , il mentionne un bref aperçu des balises:

Une déclaration de champ peut être suivie d'une balise littérale de chaîne facultative, qui devient un attribut pour tous les champs de la déclaration de champ correspondante. Les balises sont rendues visibles à travers une interface de réflexion mais sont sinon ignorées.

// A struct corresponding to the TimeStamp protocol buffer.
// The tag strings define the protocol buffer field numbers.
struct {
  microsec  uint64 "field 1"
  serverIP6 uint64 "field 2"
  process   string "field 3"
}

Ceci est une très courte explication OMI, et je me demandais si quelqu'un pourrait me fournir à quoi serviraient ces balises?

Une balise pour un champ vous permet d'attacher des méta-informations au champ qui peuvent être acquises par réflexion. Habituellement, il est utilisé pour fournir des informations de transformation sur la façon dont un champ struct est codé ou décodé à partir d'un autre format (ou stocké / récupéré à partir d'une base de données), mais vous pouvez l'utiliser pour stocker les méta-informations que vous souhaitez, destinées à un autre paquet ou pour votre propre usage.

Comme mentionné dans la documentation de reflect.StructTag, par convention, la valeur d'une chaîne de balises est une liste de key:"value"paires séparées par des espaces , par exemple:

type User struct {
    Name string `json:"name" xml:"name"`
}

le key désigne généralement le package pour lequel le suivant "value"est destiné, par exemple les jsonclés sont traitées / utilisées par le encoding/jsonpackage.

Si plusieurs informations doivent être transmises dans le "value", elles sont généralement spécifiées en les séparant par une virgule ( ','), par exemple

Name string `json:"name,omitempty" xml:"name"`

Habituellement, une valeur de tiret ( '-') pour les "value"moyens d'exclure le champ du processus (par exemple, dans le cas où jsoncela signifie de ne pas marshaler ou démarsaler ce champ).

Exemple d'accès à vos balises personnalisées à l'aide de la réflexion

Nous pouvons utiliser la réflexion ( reflectpackage) pour accéder aux valeurs des balises des champs struct. Fondamentalement, nous devons acquérir le Typede notre structure, puis nous pouvons interroger des champs, par exemple avec Type.Field(i int)ou Type.FieldByName(name string). Ces méthodes renvoient une valeur StructFieldqui décrit / représente un champ struct; et StructField.Tagest une valeur de type StructTagqui décrit / représente une valeur de balise.

Auparavant, nous parlions de «convention» . Ce moyen de la convention que si vous le suivez, vous pouvez utiliser la StructTag.Get(key string)méthode qui analyse la valeur d'une variable et vous renvoie le "value"de keyvous spécifiez. La convention est implémentée / intégrée dans cette Get()méthode. Si vous ne respectez pas la convention, vous Get()ne pourrez pas analyser les key:"value"paires et trouver ce que vous cherchez. Ce n'est pas non plus un problème, mais vous devez ensuite implémenter votre propre logique d'analyse.

Il y a aussi StructTag.Lookup()(a été ajouté dans Go 1.7) qui est "similaire Get()mais distingue la balise ne contenant pas la clé donnée de la balise associant une chaîne vide à la clé donnée" .

Voyons donc un exemple simple:

type User struct {
    Name  string `mytag:"MyName"`
    Email string `mytag:"MyEmail"`
}

u := User{"Bob", "bob@mycompany.com"}
t := reflect.TypeOf(u)

for _, fieldName := range []string{"Name", "Email"} {
    field, found := t.FieldByName(fieldName)
    if !found {
        continue
    }
    fmt.Printf("\nField: User.%s\n", fieldName)
    fmt.Printf("\tWhole tag value : %q\n", field.Tag)
    fmt.Printf("\tValue of 'mytag': %q\n", field.Tag.Get("mytag"))
}

Sortie (essayez-la sur le Go Playground ):

Field: User.Name
    Whole tag value : "mytag:\"MyName\""
    Value of 'mytag': "MyName"

Field: User.Email
    Whole tag value : "mytag:\"MyEmail\""
    Value of 'mytag': "MyEmail"

GopherCon 2015 avait une présentation sur les balises struct appelée:

Les nombreux visages des balises Struct (diapositive) (et une vidéo )

Voici une liste des clés de balise couramment utilisées:

• json     - utilisé par le encoding/jsonpackage, détaillé àjson.Marshal()
• xml      - utilisé par le encoding/xmlpackage, détaillé àxml.Marshal()
• bson     - utilisé par gobson , détaillé àbson.Marshal()
• protobuf - utilisé par github.com/golang/protobuf/proto, détaillé dans le paquet doc
• yaml     - utilisé par le gopkg.in/yaml.v2package, détaillé àyaml.Marshal()
• db       - utilisé par le github.com/jmoiron/sqlxpackage; également utilisé par github.com/go-gorp/gorppackage
• orm      - utilisé par le github.com/astaxie/beego/ormpackage, détaillé sur les modèles - Beego ORM
• gorm     - utilisé par le github.com/jinzhu/gormpackage, des exemples peuvent être trouvés dans leur doc: Modèles
• valid    - utilisé par le github.com/asaskevich/govalidatorpackage, des exemples peuvent être trouvés dans la page du projet
• datastore- utilisé par appengine/datastore(plate-forme Google App Engine, service Datastore), détaillé à Propriétés
• schema   - utilisé par github.com/gorilla/schemapour remplir unstruct avec des valeurs de formulaire HTML, détaillées dans le paquet doc
• asn      - utilisé par le encoding/asn1package, détaillé à asn1.Marshal()etasn1.Unmarshal()
• csv      - utilisé par le github.com/gocarina/gocsvpackage

Voici un exemple très simple de balises utilisées avec le encoding/json package pour contrôler la façon dont les champs sont interprétés pendant l'encodage et le décodage:

Essayez en direct: http://play.golang.org/p/BMeR8p1cKf

package main

import (
    "fmt"
    "encoding/json"
)

type Person struct {
    FirstName  string `json:"first_name"`
    LastName   string `json:"last_name"`
    MiddleName string `json:"middle_name,omitempty"`
}

func main() {
    json_string := `
    {
        "first_name": "John",
        "last_name": "Smith"
    }`

    person := new(Person)
    json.Unmarshal([]byte(json_string), person)
    fmt.Println(person)

    new_json, _ := json.Marshal(person)
    fmt.Printf("%s\n", new_json)
}

// *Output*
// &{John Smith }
// {"first_name":"John","last_name":"Smith"}

Le package json peut regarder les balises du champ et savoir comment mapper le champ struct json <=>, ainsi que des options supplémentaires comme s'il doit ignorer les champs vides lors de la sérialisation vers json.

Fondamentalement, tout package peut utiliser la réflexion sur les champs pour examiner les valeurs des balises et agir sur ces valeurs. Il y a un peu plus d'informations à leur sujet dans le package Reflect
http://golang.org/pkg/reflect/#StructTag :

Par convention, les chaînes de balises sont une concaténation de paires de clés éventuellement séparées par des espaces: "valeur". Chaque clé est une chaîne non vide composée de caractères non contrôlés autres que l'espace (U + 0020 ''), la citation (U + 0022 '"') et les deux points (U + 003A ':'). Chaque valeur est citée en utilisant les caractères U + 0022 '"' et la syntaxe littérale de la chaîne Go.

C'est une sorte de spécifications qui spécifie comment les packages sont traités avec un champ balisé.

par exemple:

type User struct {
    FirstName string `json:"first_name"`
    LastName string `json:"last_name"`
}

La balise json informe le jsonpackage que la sortie a été gérée par l'utilisateur suivant

u := User{
        FirstName: "some first name",
        LastName:  "some last name",
    }

serait comme ça:

{"first_name":"some first name","last_name":"some last name"}

un autre exemple est gormles balises de package déclarent comment les migrations de base de données doivent être effectuées:

type User struct {
  gorm.Model
  Name         string
  Age          sql.NullInt64
  Birthday     *time.Time
  Email        string  `gorm:"type:varchar(100);unique_index"`
  Role         string  `gorm:"size:255"` // set field size to 255
  MemberNumber *string `gorm:"unique;not null"` // set member number to unique and not null
  Num          int     `gorm:"AUTO_INCREMENT"` // set num to auto incrementable
  Address      string  `gorm:"index:addr"` // create index with name `addr` for address
  IgnoreMe     int     `gorm:"-"` // ignore this field
}

Dans cet exemple pour le champ Emailavec la balise gorm, nous déclarons que la colonne correspondante dans la base de données pour le champ e-mail doit être de type varchar et 100 de longueur maximale et doit également avoir un index unique.

un autre exemple est les bindingbalises qui sont utilisées très majoritairement dans les ginpackages.

type Login struct {
    User     string `form:"user" json:"user" xml:"user"  binding:"required"`
    Password string `form:"password" json:"password" xml:"password" binding:"required"`
}


var json Login
if err := c.ShouldBindJSON(&json); err != nil {
     c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
     return
}

la balise de liaison dans cet exemple indique au package gin que les données envoyées à l'API doivent avoir des champs d'utilisateur et de mot de passe car ces champs sont balisés comme requis.

Les balises générales sont donc des données dont les packages ont besoin pour savoir comment traiter les données avec des structures de type différent et la meilleure façon de se familiariser avec les balises dont un package a besoin est de LIRE UNE DOCUMENTATION COMPLÈTE COMPLÈTEMENT.