แท็กใน Go มีประโยชน์อะไรบ้าง?

ในGo Language Specificationจะกล่าวถึงภาพรวมโดยย่อของแท็ก:

การประกาศฟิลด์อาจตามด้วยแท็กตัวอักษรของสตริงซึ่งเป็นคุณสมบัติสำหรับฟิลด์ทั้งหมดในการประกาศฟิลด์ที่สอดคล้องกัน แท็กนั้นสามารถมองเห็นได้ผ่านอินเทอร์เฟซการสะท้อน แต่ไม่สนใจ

// 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"
}

นี่เป็นคำอธิบายสั้น ๆ ของ IMO และฉันสงสัยว่าใครจะให้แท็กเหล่านี้กับฉันได้บ้าง

แท็กสำหรับเขตข้อมูลช่วยให้คุณสามารถแนบข้อมูลเมตาไปยังเขตข้อมูลที่สามารถรับได้โดยใช้การสะท้อน โดยปกติจะใช้เพื่อให้ข้อมูลการแปลงว่าฟิลด์ struct ถูกเข้ารหัสไปยังหรือถอดรหัสจากรูปแบบอื่น (หรือจัดเก็บ / ดึงจากฐานข้อมูล) แต่คุณสามารถใช้เพื่อเก็บข้อมูลเมตาใด ๆ ที่คุณต้องการ แพคเกจหรือสำหรับการใช้งานของคุณเอง

ตามที่กล่าวไว้ในเอกสารประกอบของreflect.StructTagโดยการประชุมค่าของสตริงแท็กเป็นรายการkey:"value"คู่คั่นด้วยช่องว่างตัวอย่างเช่น:

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

keyมักจะหมายถึงแพคเกจที่ตามมา"value"เป็นเช่นjsonปุ่มมีการประมวลผล / ใช้โดยencoding/jsonแพคเกจ

หากมีการส่งผ่านข้อมูลจำนวนมากใน"value"โดยทั่วไปจะมีการระบุโดยคั่นด้วยเครื่องหมายจุลภาค ( ',') เช่น

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

มักจะเป็นค่าเส้นประ ( '-') สำหรับ"value"วิธีการที่จะแยกสนามออกจากกระบวนการ (เช่นในกรณีที่jsonมันหมายถึงไม่ให้จอมพลหรือ unmarshal ฟิลด์นั้น)

ตัวอย่างการเข้าถึงแท็กที่กำหนดเองโดยใช้การสะท้อน

เราสามารถใช้การสะท้อน ( reflectแพ็คเกจ) เพื่อเข้าถึงค่าแท็กของเขตข้อมูล struct โดยทั่วไปเราต้องการที่จะได้รับTypeของ struct ของเราและจากนั้นเราสามารถสอบถามสาขาเช่นด้วยหรือType.Field(i int) Type.FieldByName(name string)เมธอดเหล่านี้ส่งคืนค่าStructFieldซึ่งอธิบาย / แทนฟิลด์ struct และStructField.Tagเป็นค่าประเภทStructTagที่อธิบาย / แสดงถึงค่าแท็ก

ก่อนหน้านี้เราได้พูดคุยเกี่ยวกับ"การประชุม" อนุสัญญานี้หมายความว่าหากคุณทำตามคุณสามารถใช้StructTag.Get(key string)วิธีการแยกวิเคราะห์ค่าของแท็กและส่งคืนค่า"value"ที่keyคุณระบุ ประชุมจะดำเนินการ / สร้างขึ้นในนี้Get()วิธีการ หากคุณไม่ปฏิบัติตามอนุสัญญาGet()จะไม่สามารถแยกkey:"value"คู่และค้นหาสิ่งที่คุณกำลังมองหา นั่นไม่ใช่ปัญหา แต่คุณต้องใช้ตรรกะการแยกวิเคราะห์ของคุณเอง

นอกจากนี้ยังมีStructTag.Lookup()(ถูกเพิ่มเข้ามาใน Go 1.7) ซึ่งเป็น"เหมือนGet()แต่แตกต่างแท็กไม่ได้มีคีย์ที่กำหนดจากแท็กเชื่อมโยงสตริงที่ว่างเปล่าที่มีคีย์ที่กำหนด"

ดังนั้นเรามาดูตัวอย่างง่ายๆ:

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"))
}

เอาท์พุท (ลองไปที่สนามเด็กเล่นไป ):

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 มีการนำเสนอเกี่ยวกับแท็ก struct ชื่อ:

แท็กโครงสร้างหลายหน้า (ภาพนิ่ง) (และวิดีโอ )

นี่คือรายการของคีย์แท็กที่ใช้กันทั่วไป:

• json     - ใช้โดยencoding/jsonแพ็คเกจโดยมีรายละเอียดที่json.Marshal()
• xml      - ใช้โดยencoding/xmlแพ็คเกจโดยมีรายละเอียดที่xml.Marshal()
• bson     - ใช้โดยgobsonโดยละเอียดที่bson.Marshal()
• protobuf - ใช้โดยgithub.com/golang/protobuf/protoมีรายละเอียดในเอกสารแพคเกจ
• yaml     - ใช้โดยgopkg.in/yaml.v2แพ็คเกจโดยมีรายละเอียดที่yaml.Marshal()
• db       - ใช้โดยgithub.com/jmoiron/sqlxแพ็คเกจ; ยังใช้โดยgithub.com/go-gorp/gorpแพคเกจ
• orm      - ใช้โดยgithub.com/astaxie/beego/ormแพ็คเกจโดยมีรายละเอียดที่รุ่น - Beego ORM
• gorm     - ใช้โดยgithub.com/jinzhu/gormแพคเกจตัวอย่างสามารถพบได้ในเอกสารของพวกเขา: โมเดล
• valid    - ใช้โดยgithub.com/asaskevich/govalidatorแพ็คเกจตัวอย่างสามารถพบได้ในหน้าโครงการ
• datastore- ใช้งานโดยappengine/datastore(แพลตฟอร์ม Google App Engine, บริการดาต้าสโตร์) โดยละเอียดที่Properties
• schema   - ใช้github.com/gorilla/schemaเพื่อกรอกstructค่าฟอร์ม HTML ที่มีรายละเอียดในเอกสารแพคเกจ
• asn      - ใช้โดยencoding/asn1แพ็คเกจโดยมีรายละเอียดที่asn1.Marshal()และasn1.Unmarshal()
• csv      - ใช้โดยgithub.com/gocarina/gocsvแพ็คเกจ

นี่คือตัวอย่างง่ายๆของแท็กที่ใช้กับencoding/jsonแพคเกจเพื่อควบคุมวิธีการตีความฟิลด์ในระหว่างการเข้ารหัสและถอดรหัส:

ลองใช้สด: 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"}

แพคเกจ json สามารถดูแท็กสำหรับฟิลด์และบอกวิธีการแมป json <=> โครงสร้าง struct และตัวเลือกพิเศษเช่นว่าควรละเว้นฟิลด์ว่างเมื่อทำการซีเรียลกลับเป็น json

โดยทั่วไปแพ็คเกจใด ๆ สามารถใช้การสะท้อนบนฟิลด์เพื่อดูค่าแท็กและดำเนินการกับค่าเหล่านั้น มีข้อมูลเพิ่มเติมเล็กน้อยเกี่ยวกับพวกเขาในแพ็คเกจการสะท้อน
http://golang.org/pkg/reflect/#StructTag :

โดยการประชุมสตริงแท็กคือการต่อเชื่อมของคีย์คั่นด้วยช่องว่างทางเลือก: "ค่า" คู่ แต่ละคีย์คือสตริงที่ไม่ว่างประกอบด้วยอักขระที่ไม่สามารถควบคุมได้นอกเหนือจากช่องว่าง (U + 0020 ''), เครื่องหมายคำพูด (U + 0022 '' '), และเครื่องหมายโคลอน (U + 003A': ') แต่ละค่าจะถูกยกมา ใช้อักขระ U + 0022 '"' และใช้ตัวอักษรไวยากรณ์ตัวอักษรของสตริง

เป็นข้อมูลจำเพาะบางประเภทที่ระบุว่าแพ็คเกจปฏิบัติกับฟิลด์ที่ถูกแท็กอย่างไร

ตัวอย่างเช่น:

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

แท็ก json แจ้งjsonแพ็กเกจที่ marshalled เอาต์พุตของผู้ใช้ต่อไปนี้

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

จะเป็นเช่นนี้:

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

ตัวอย่างอื่น ๆ คือgormแท็กแพ็กเกจประกาศว่าจะต้องทำการโยกย้ายฐานข้อมูลอย่างไร:

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
}

ในตัวอย่างนี้สำหรับฟิลด์ที่Emailมีแท็ก gorm เราประกาศว่าคอลัมน์ที่สอดคล้องกันในฐานข้อมูลสำหรับอีเมลภาคสนามจะต้องเป็นประเภท varchar และความยาวสูงสุด 100 และมันจะต้องมีดัชนีที่ไม่ซ้ำกัน

ตัวอย่างอื่น ๆ คือbindingแท็กที่ใช้ส่วนใหญ่ในginแพ็คเกจ

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
}

แท็กการโยงในตัวอย่างนี้ให้คำแนะนำกับแพคเกจจินที่ข้อมูลที่ส่งไปยัง API ต้องมีฟิลด์ผู้ใช้และรหัสผ่านทำให้เกิดการติดแท็กฟิลด์เหล่านี้ตามที่ต้องการ

ดังนั้นแท็กทั่วไปคือข้อมูลที่แพ็กเกจต้องการทราบว่าควรจัดการกับข้อมูลประเภท struct ที่แตกต่างกันอย่างไรและวิธีที่ดีที่สุดในการทำความคุ้นเคยกับแท็กความต้องการของแพ็กเกจคือการอ่านเอกสารเสร็จสมบูรณ์