Golang中的結構體和反射示例詳解
更新時間：2025年10月11日 10:27:44 作者：O.0)O.O(0.O
文章介紹了Go語言中結構體的使用、結構體與JSON數(shù)據(jù)的轉換以及反射機制,反射允許在運行時獲取類型信息、動態(tài)調用方法、訪問屬性和構造對象,文章還提到了使用reflect包來獲取和操作結構體的字段、方法、類型和值,本文結合實例代碼介紹的非常詳細,感興趣的朋友一起看看吧
結構體
聲明
// 聲明一種新的類型 myint，是int的別名
type myint int
// 定義一個結構體:把多種基本數(shù)據(jù)類型組合到一起變成一個新的類型
type Book struct {
title string
author string
price myint
}
func changeBook(book Book) {
//傳遞的是值類型，所以修改的是副本，不會影響原來的變量
book.price = 999
}
func changeBook1(book *Book) {
// 指針類型可以修改結構體變量的值
book.author = "新作者"
}
func main() {
var a myint = 10
fmt.Println("a =", a)
fmt.Printf("type of a is %T\n", a)
var book1 Book
book1.title = "Go 語言"
book1.author = "老子"
book1.price = 299
fmt.Println("book1 =", book1)
fmt.Printf("type of book1 is %T\n", book1)
changeBook(book1)
fmt.Println("--------------")
fmt.Println("book1 =", book1)
changeBook1(&book1)
fmt.Println("--------------")
fmt.Println("book1 =", book1)
}
=================================================
PS D:\GoProject\firstGoProject> go run firstGoProject.go
a = 10
type of a is main.myint
book1 = {Go 語言 老子 299}
type of book1 is main.Book
--------------
book1 = {Go 語言 老子 299}
--------------
book1 = {Go 語言 新作者 299}結構體的使用
import "fmt"
//如果類名首字母大寫，表示其他包也可以訪問
type Hero struct {
//如果類的屬性首字母大寫，表示其他包也可以訪問，否則只能在本包中訪問
Name string
Ad int
Level int
}
func (this Hero) GetName() string {
return this.Name
}
func (this Hero) SetName(newName string) {
//當前this是調用該方法的對象的拷貝
this.Name = newName
}
func (this Hero) ShowInfo() {
fmt.Println("hero = ", this)
}
func (this *Hero) SetName1(newName string) {
//這里的this是指針類型，所以可以修改對象的值
this.Name = newName
}
func main() {
// create a Hero object
hero := Hero{Name: "Alice", Ad: 100, Level: 10}
var name = hero.GetName()
fmt.Println("name = ", name)
hero.ShowInfo()
hero.SetName("Bob")
hero.ShowInfo()
hero.SetName1("Charlie")
hero.ShowInfo()
}
-----------------------------------------------------
PS D:\GoProject\firstGoProject> go run firstGoProject.go
name = Alice
hero = {Alice 100 10}
hero = {Alice 100 10}
hero = {Charlie 100 10}結構體和json數(shù)據(jù)的互相轉換
import (
"encoding/json"
"fmt"
)
type Movie struct {
Title string `json:"title"` //結構體的標簽
Year int `json:"year"`
Price int `json:"price"`
Actors []string `json:"actors"`
}
func main() {
movie := Movie{
Title: "The Dark Knight",
Year: 2008,
Price: 150,
Actors: []string{"Christopher Nolan", "Robert Duvall"},
}
//編碼的過程 結構體 ---> json
jsonStr, err := json.Marshal(movie)
if err != nil {
fmt.Println("json marshal error", err)
}
fmt.Printf("jsonStr = %s\n", jsonStr)
//解碼的過程 json ---> 結構體
//jsonStr = {"title":"The Dark Knight","year":2008,"price":150,"actors":["Christopher Nolan","Robert Duvall"]}
myMovie := Movie{}
err = json.Unmarshal(jsonStr, &myMovie)
if err != nil {
fmt.Println("json unmarshal error", err)
return
}
fmt.Printf("myMovie = %v\n", myMovie)
}PS D:\GoProject\firstGoProject> go run firstGoProject.go
jsonStr = {"title":"The Dark Knight","year":2008,"price":150,"actors":["Christopher Nolan","Robert Duvall"]}
myMovie = {The Dark Knight 2008 150 [Christopher Nolan Robert Duvall]}反射
反射（Reflection） 是指在程序運行時可以訪問、檢測和修改其自身狀態(tài)或行為的一種能力。
具體來說，在面向對象編程中，反射允許程序：
- 在運行時獲取類型信息（類名、方法、屬性、注解等）
- 動態(tài)調用方法或訪問屬性
- 構造對象（即使編譯時不知道具體類）
- 檢查并操作類成員
反射機制允許程序在運行時獲取類型信息并動態(tài)調用成員，而不需要在編譯時確定具體的類或方法。
變量內(nèi)置pair結構
一個變量中含有type 和 value ，稱作pair
type分為 static type 和 concrete type，變量的type是兩者中的一個（不能同時有兩個type）
import "fmt"
func main() {
var a string
//pair <type:static type(string), value:"Hello, World!">
a = "Hello, World!"
//pair <type:constant type, value: nil>
var allType interface{}
//pair <type:string, value:"Hello, World!">
allType = a
str, _ := allType.(string)
fmt.Println(str)
}
-------------------------------------------------------
PS D:\GoProject\firstGoProject> go run firstGoProject.go
Hello, World!import (
"fmt"
"io"
"os"
)
func main() {
//tty: pair<type: *os.File, value: "/dev/tty" 文件描述符>
tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
if err != nil {
fmt.Println(err)
return
}
//r: pair<type: ,value: >
var r io.Reader
//r: pair<type: *os.File, value: "/dev/tty" 文件描述符>
r = tty
//w: pair<type: ,value: >
var w io.Writer
//w: pair<type: *os.File, value: "/dev/tty" 文件描述符>
w = r.(io.Writer)
w.Write([]byte("Hello, world!\n")) // 向終端輸出 "Hello, world!\n"
}type Reader interface {
ReadBook()
}
type Writer interface {
WriteBook()
}
// 具體類型
type Book struct {
}
func (this *Book) ReadBook() {
fmt.Println("Reading book...")
}
func (this *Book) WriteBook() {
fmt.Println("Writing book...")
}
func main() {
// 接口變量 b:pair<type:Book,value:book{}地址>
b := &Book{}
// 接口變量 r:pair<type:,value:>
var r Reader
//此時r的類型為nil
fmt.Printf("r: %T\n", r)
//r:pair<type:Book,value:book{}地址>
r = b
// 調用接口方法
r.ReadBook()
var w Writer
w = r.(Writer)
w.WriteBook()
}
-------------------------------------------------------------
PS D:\GoProject\firstGoProject> go run firstGoProject.go
r: <nil>
Reading book...
Writing book...reflect包
獲取字段的類型和值
import (
"fmt"
"reflect"
)
func reflectNum(arg interface{}) {
fmt.Println("type :", reflect.TypeOf(arg))
fmt.Println("value:", reflect.ValueOf(arg))
}
func main() {
var num float64 = 3.14
reflectNum(num)
}
----------------------------------------------
PS D:\GoProject\firstGoProject> go run firstGoProject.go
type : float64
value: 3.14獲取結構體字段、方法的名稱、類型和值
import (
"fmt"
"reflect"
)
type User struct {
Id int
Name string
Age int
}
func (this User) Call() {
fmt.Println("user is called ..")
fmt.Printf("%v\n", this)
}
func main() {
user := User{1, "John", 25}
DoFileAndMethod(user)
}
func DoFileAndMethod(input interface{}) {
//獲取input的類型
inputType := reflect.TypeOf(input)
fmt.Println("inputType is:", inputType.Name())
//獲取input的value
inputValue := reflect.ValueOf(input)
fmt.Println("inputValue is:", inputValue)
//通過type獲取里面的字段
//1. 獲取interface的reflect.Type，通過Type得到NumField,進行遍歷
//2. 得到每個field，數(shù)據(jù)類型
//3. 通過filed有一個Interface()方法等到 對應的value
for i := 0; i < inputType.NumField(); i++ {
field := inputType.Field(i)
value := inputValue.Field(i).Interface()
fmt.Printf("field = %s,type = %v, value = %v\n", field.Name, field.Type, value)
}
fmt.Println("--------------------", inputType.NumMethod())
//通過type獲取里面的方法，調用
for i := 0; i < inputType.NumMethod(); i++ {
m := inputType.Method(i)
fmt.Printf("%s,%v\n", m.Name, m.Type)
}
}PS D:\GoProject\firstGoProject> go run firstGoProject.go
inputType is: User
inputValue is: {1 John 25}
field = Id,type = int, value = 1
field = Name,type = string, value = John
field = Age,type = int, value = 25
-------------------- 1
Call,func(main.User)解析結構體標簽Tag
import (
"fmt"
"reflect"
)
type resume struct {
Name string `info:"name" doc:"我的名字"`
Sex string `info:"sex" doc:"我的性別"`
}
func findTag(str interface{}) {
t := reflect.TypeOf(str).Elem()
for i := 0; i < t.NumField(); i++ {
taginfo := t.Field(i).Tag.Get("info")
tagdoc := t.Field(i).Tag.Get("doc")
fmt.Println("info:", taginfo, "doc:", tagdoc)
}
}
func main() {
var re resume
findTag(&re)
}PS D:\GoProject\firstGoProject> go run firstGoProject.go info: name doc: 我的名字 info: sex doc: 我的性別
到此這篇關于Golang的結構體和反射的文章就介紹到這了,更多相關go 結構體和反射內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
這篇文章主要為大家詳細介紹了Go語言中包的介紹與初始化,從而搞清Go程序的執(zhí)行次序,文中的示例代碼講解詳細,感興趣的小伙伴可以跟隨小編一起了解下2023-10-10
這篇文章主要介紹了Golang 日志處理和正則處理的操作方法,本文通過實例代碼給大家介紹的非常詳細,對大家的學習或工作具有一定的參考借鑒價值,需要的朋友參考下吧2025-06-06
go內(nèi)存隊列l(wèi)ist VS slice實現(xiàn)方式對比分析
這篇文章主要為大家介紹了go內(nèi)存隊列l(wèi)ist VS slice實現(xiàn)方式對比分析,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪2023-08-08
net/http是Go語言標準庫中用于處理HTTP協(xié)議的核心組件,它提供了完整HTTP客戶端和服務器實現(xiàn),這個包讓開發(fā)者能夠快速構建高性能的Web服務,無需依賴第三方框架,感興趣的可以了解一下2025-10-10
這篇文章主要介紹了go語言中并發(fā)安全和鎖問題,包含互斥鎖解鎖過程，本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2021-10-10
本文主要介紹了Golang的鎖機制與使用技巧小結，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2022-06-06
這篇文章主要介紹了golang簡單獲取上傳文件大小的方法,涉及Go語言文件傳輸及文件屬性操作的相關技巧,需要的朋友可以參考下2016-07-07
一文詳解如何在Golang中實現(xiàn)JWT認證與授權
在現(xiàn)代Web應用中,安全性是一個非常重要的課題,JWT作為一種常用的認證與授權機制,已被廣泛應用于各種系統(tǒng)中,下面我們就來看看如何在Golang中實現(xiàn)JWT認證與授權吧2025-03-03
Go語言實現(xiàn)統(tǒng)計字符串中每個字符出現(xiàn)的次數(shù)
這篇文章主要為大家詳細介紹了如何使用Go語言開發(fā)一個簡易頻率分析器,實現(xiàn)統(tǒng)計字符串中每個字符出現(xiàn)的次數(shù),感興趣的小伙伴可以了解一下2025-07-07
這篇文章主要為大家介紹了Go中的fuzz模糊測試使用實戰(zhàn)詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2023-12-12