个人中心
gpt4 book ai didi

浅谈Go语言中的结构体struct 反射

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 30 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章浅谈Go语言中的结构体struct 反射由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

结构体struct 。

struct 用来自定义复杂数据结构，可以包含多个字段（属性），可以嵌套； 。

go中的struct类型理解为类，可以定义方法，和函数定义有些许区别； 。

struct类型是值类型.

struct定义 。

?
1
2
3
4
5
type User struct {
  Name string
  Age int32
  mess string
}
?
1
2
3
var user User
var user1 *User = &User{}
var user2 *User = new (User)

struct使用 。

下面示例中user1和user2为指针类型，访问的时候编译器会自动把 user1.Name 转为 (*user1).Name 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
func main() {
  var user User
  user.Name = "nick"
  user.Age = 18
  user.mess = "lover"
 
  var user1 *User = &User{
   Name: "dawn",
   Age: 21,
  }
  fmt.Println(*user1)     //{dawn 21 }
  fmt.Println(user1.Name, (*user1).Name) //dawn dawn
 
  var user2 *User = new(User)
  user2.Name = "suoning"
  user2.Age = 18
  fmt.Println(user2)      //&{suoning 18 }
  fmt.Println(user2.Name, (*user2).Name) //suoning suoning
}

构造函数 。

golang中的struct没有构造函数，可以伪造一个 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
type User struct {
  Name string
  Age int32
  mess string
}
 
func NewUser(name string, age int32, mess string) *User {
  return &User{Name:name,Age:age,mess:mess}
}
 
func main() {
  //user := new(User)
  user := NewUser("suoning", 18, "lover")
  fmt.Println(user, user.mess, user.Name, user.Age)
}

内存布局 。

struct中的所有字段在内存是连续的 。

?
1
2
3
4
5
6
7
8
9
var user User
  user.Name = "nick"
  user.Age = 18
  user.mess = "lover"
 
  fmt.Println(user)     //{nick 18 lover}
  fmt.Printf("Name:%p\n", &user.Name) //Name:0xc420016180
  fmt.Printf("Age: %p\n", &user.Age) //Age: 0xc420016190
  fmt.Printf("mess:%p\n", &user.mess) //mess:0xc420016198 8字节为内存对齐

方法 。

方法是作用在特定类型的变量上，因此自定义类型，都可以有方法，而不仅仅是struct.

方法的访问控制也是通过大小写控制.

init函数是通过传入指针实现，这样改变struct字段值，因为是值类型.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
type User struct {
  Name string
  Age int
  sex string
}
 
func (this *User) init(name string, age int, sex string) {
  this.Name = name
  this.Age = age
  this.sex = sex
}
 
func (this User) GetName() string {
  return this.Name
}
 
func main() {
  var user User
  user.init("nick", 18, "man")
  //(&user).init("nick", 18, "man")
  name := user.GetName()
  fmt.Println(name)
}

匿名字段 。

如果有冲突的， 则最外的优先 。

?
1
2
3
4
5
6
7
8
9
10
11
type User struct {
  Name stirng
  Age int 
}
 
type Lover struct {
   User
   sex time.Time
   int
   Age int
}

继承 & 多重继承 。

一个结构体继承多个结构体，访问通过点。继承字段以及方法.

可以起别名，如下面 u1（user1），访问 user.u1.Age.

如果继承的结构体都拥有同一个字段，通过user.name访问就会报错，必须通过user.user1.name来访问.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
type user1 struct {
  name string
  Age int
}
 
type user2 struct {
  name string
  age int
  sex time.Time
}
 
type User struct {
  u1 user1 //别名
  user2
  Name string
  Age int
}
 
func main() {
  var user User
  user.Name = "nick"
  user.u1.Age = 18
  fmt.Println(user) //{{ 18} { 0 {0 0 < nil >}} nick 0}
}

tag 。

在go中，首字母大小写有特殊的语法含义，小写包外无法引用。由于需要和其它的系统进行数据交互，例如转成json格式。这个时候如果用属性名来作为键值可能不一定会符合项目要求。tag在转换成其它数据格式的时候，会使用其中特定的字段作为键值.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import "encoding/json"
 
type User struct {
  Name string `json:"userName"`
  Age int `json:"userAge"`
}
 
func main() {
  var user User
  user.Name = "nick"
  user.Age = 18
 
  conJson, _ := json.Marshal(user)
  fmt.Println(string(conJson)) //{"userName":"nick","userAge":0}
}

String() 。

如果实现了String()这个方法，那么fmt默认会调用String().

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
type name1 struct {
  int
  string
}
 
func (this *name1) String() string {
  return fmt.Sprintf("This is String(%s).", this.string)
}
 
func main() {
  n := new(name1)
  fmt.Println(n) //This is String().
  n.string = "suoning"
  d := fmt.Sprintf("%s", n) //This is String(suoning).
  fmt.Println(d)
}

接口Interface 。

Interface类型可以定义一组方法，但是这些不需要实现。并且interface不能包含任何变量.

interface类型默认是一个指针.

Interface定义 。

?
1
2
3
4
5
type Car interface {
  NameGet() string
  Run(n int)
  Stop()
}

Interface实现 。

Golang中的接口，不需要显示的实现。只要一个变量，含有接口类型中的所有方法，那么这个变量就实现这个接口。因此，golang中没有implement类似的关键字； 。

如果一个变量含有了多个interface类型的方法，那么这个变量就实现了多个接口；如果一个变量只含有了1个interface的方部分方法，那么这个变量没有实现这个接口.

空接口 Interface{}：空接口没有任何方法，所以所有类型都实现了空接口.

?
1
2
3
var a int
var b interface{} //空接口
b = a

多态 。

一种事物的多种形态，都可以按照统一的接口进行操作.

栗子:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
type Car interface {
  NameGet() string
  Run(n int)
  Stop()
}
 
type BMW struct {
  Name string
}
func (this *BMW) NameGet() string {
  return this.Name
}
func (this *BMW) Run(n int) {
  fmt.Printf("BMW is running of num is %d \n", n)
}
func (this *BMW) Stop() {
  fmt.Printf("BMW is stop \n")
}
 
type Benz struct {
  Name string
}
func (this *Benz) NameGet() string {
  return this.Name
}
func (this *Benz) Run(n int) {
  fmt.Printf("Benz is running of num is %d \n", n)
}
func (this *Benz) Stop() {
  fmt.Printf("Benz is stop \n")
}
func (this *Benz) ChatUp() {
  fmt.Printf("ChatUp \n")
}
 
func main() {
  var car Car
  fmt.Println(car) // < nil >
 
  var bmw BMW = BMW{Name: "宝马"}
  car = &bmw
  fmt.Println(car.NameGet()) //宝马
  car.Run(1)     //BMW is running of num is 1
  car.Stop()     //BMW is stop
 
  benz := &Benz{Name: "大奔"}
  car = benz
  fmt.Println(car.NameGet()) //大奔
  car.Run(2)     //Benz is running of num is 2
  car.Stop()     //Benz is stop
  //car.ChatUp() //ERROR: car.ChatUp undefined (type Car has no field or method ChatUp)
}

Interface嵌套 。

一个接口可以嵌套在另外的接口.

即需要实现2个接口的方法.

?
1
2
3
4
5
6
7
8
9
10
type Car interface {
  NameGet() string
  Run(n int)
  Stop()
}
 
type Used interface {
  Car
  Cheap()
}

类型断言 。

类型断言，由于接口是一般类型，不知道具体类型， 。

如果要转成具体类型，可以采用以下方法进行转换:

?
1
2
3
4
5
6
var t int
var x interface{}
x = t
 
y = x.(int)  //转成int
y, ok = x.(int) //转成int，不报错

栗子一:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
func test(i interface{}) {
  // n := i.(int)
  n, ok := i.(int)
  if !ok {
   fmt.Println("error")
   return
  }
  n += 10
  fmt.Println(n)
}
 
func main() {
  var t1 int
  test(t1)
}

栗子二:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
switch & type
 
 
type Student struct {
  Name string
}
 
func judgmentType(items ...interface{}) {
  for k, v := range items {
   switch v.(type) {
   case string:
    fmt.Printf("string, %d[%v]\n", k, v)
   case bool:
    fmt.Printf("bool, %d[%v]\n", k, v)
   case int, int32, int64:
    fmt.Printf("int, %d[%v]\n", k, v)
   case float32, float64:
    fmt.Printf("float, %d[%v]\n", k, v)
   case Student:
    fmt.Printf("Student, %d[%v]\n", k, v)
   case *Student:
    fmt.Printf("Student, %d[%p]\n", k, v)
   }
  }
}
 
func main() {
  stu1 := &Student{Name: "nick"}
  judgmentType(1, 2.2, "learing", stu1)
}

栗子三:

判断一个变量是否实现了指定接口 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
type Stringer interface {
  String() string
}
 
type Mystruct interface {
 
}
type Mystruct2 struct {
 
}
func (this *Mystruct2) String() string {
  return ""
}
 
func main() {
  var v Mystruct
  var v2 Mystruct2
  v = &v2
 
  if sv, ok := v.(Stringer); ok {
   fmt.Printf("%v implements String(): %s\n", sv.String());
  }
}

反射 reflect 。

reflect包实现了运行时反射，允许程序操作任意类型的对象.

典型用法是用静态类型interface{}保存一个值， 。

　　通过调用TypeOf获取其动态类型信息，该函数返回一个Type类型值.

　　调用ValueOf函数返回一个Value类型值，该值代表运行时的数据.

func TypeOf(i interface{}) Type 。

TypeOf返回接口中保存的值的类型，TypeOf(nil)会返回nil.

func ValueOf(i interface{}) Value 。

ValueOf返回一个初始化为i接口保管的具体值的Value，ValueOf(nil)返回Value零值.

reflect.Value.Kind 。

获取变量的类别，返回一个常量 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
const (
  Invalid Kind = iota
  Bool
  Int
  Int8
  Int16
  Int32
  Int64
  Uint
  Uint8
  Uint16
  Uint32
  Uint64
  Uintptr
  Float32
  Float64
  Complex64
  Complex128
  Array
  Chan
  Func
  Interface
  Map
  Ptr
  Slice
  String
  Struct
  UnsafePointer
)
 
reflect.Value.Kind()方法返回的常量

reflect.Value.Interface() 。

转换成interface{}类型 。

【变量<-->Interface{}<-->Reflect.Value】 。

获取变量的值:

?
1
2
3
4
reflect.ValueOf(x).Int()
reflect.ValueOf(x).Float()
reflect.ValueOf(x).String()
reflect.ValueOf(x).Bool()

通过反射的来改变变量的值 。

?
1
2
3
4
reflect.Value.SetXX相关方法，比如:
reflect.Value.SetInt()，设置整数
reflect.Value.SetFloat()，设置浮点数
reflect.Value.SetString()，设置字符串

栗子一 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import "reflect"
 
func main() {
  var x float64 = 5.21
  fmt.Println("type:", reflect.TypeOf(x)) //type: float64
 
  v := reflect.ValueOf(x)
  fmt.Println("value:", v)   //value: 5.21
  fmt.Println("type:", v.Type()) //type: float64
  fmt.Println("kind:", v.Kind()) //kind: float64
  fmt.Println("value:", v.Float()) //value: 5.21
 
  fmt.Println(v.Interface())     //5.21
  fmt.Printf("value is %1.1e\n", v.Interface()) //value is 5.2e+00
  y := v.Interface().(float64)
  fmt.Println(y) //5.21
}

栗子二（修改值） 。

SetXX(x) 因为传递的是 x 的值的副本，所以SetXX不能够改 x，改动 x 必须向函数传递 x 的指针，SetXX(&x) .

?
1
2
3
4
5
6
7
8
//错误代码！！！
//panic: reflect: reflect.Value.SetFloat using unaddressable value
func main() {
  var a float64
  fv := reflect.ValueOf(&a)
  fv.SetFloat(520.00)
  fmt.Printf("%v\n", a)
}
?
1
2
3
4
5
6
7
//正确的，传指针
func main() {
  var a2 float64
  fv2 := reflect.ValueOf(&a2)
  fv2.Elem().SetFloat(520.00)
  fmt.Printf("%v\n", a2) //520
}

反射操作结构体 。

reflect.Value.NumField()获取结构体中字段的个数 。

reflect.Value.Method(n).Call(nil)来调用结构体中的方法 。

栗子一（通过反射操作结构体） 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import "reflect"
 
type NotknownType struct {
  S1 string
  S2 string
  S3 string
}
 
func (n NotknownType) String() string {
  return n.S1 + " & " + n.S2 + " & " + n.S3
}
 
var secret interface{} = NotknownType{"Go", "C", "Python"}
 
func main() {
  value := reflect.ValueOf(secret)
  fmt.Println(value) //Go & C & Python
  typ := reflect.TypeOf(secret)
  fmt.Println(typ) //main.NotknownType
 
  knd := value.Kind()
  fmt.Println(knd) // struct
 
  for i := 0; i < value.NumField(); i++ {
   fmt.Printf("Field %d: %v\n", i, value.Field(i))
  }
 
  results := value.Method(0).Call(nil)
  fmt.Println(results) // [Go & C & Python]
}

栗子二（通过反射修改结构体） 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import "reflect"
 
type T struct {
  A int
  B string
}
 
func main() {
  t := T{18, "nick"}
  s := reflect.ValueOf(&t).Elem()
  typeOfT := s.Type()
 
  for i := 0; i < s.NumField(); i++ {
   f := s.Field(i)
   fmt.Printf("%d: %s %s = %v\n", i,
    typeOfT.Field(i).Name, f.Type(), f.Interface())
  }
 
  s.Field(0).SetInt(25)
  s.Field(1).SetString("nicky")
  fmt.Println(t)
}
 
/*
输出：
0: A int = 18
1: B string = nick
{25 nicky}
*/
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import "reflect"
 
type test struct {
  S1 string
  s2 string
  s3 string
}
 
var s interface{} = &test{
  S1: "s1",
  s2: "s2",
  s3: "s3",
}
 
func main() {
  val := reflect.ValueOf(s)
  fmt.Println(val)      //&{s1 s2 s3}
  fmt.Println(val.Elem())    //{s1 s2 s3}
  fmt.Println(val.Elem().Field(0))  //s1
  val.Elem().Field(0).SetString("hehe") //S1大写
}

栗子三（struct tag 内部实现） 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main
 
import (
  "fmt"
  "reflect"
)
 
type User struct {
  Name string `json:"user_name"`
}
 
func main() {
  var user User
  userType := reflect.TypeOf(user)
  jsonString := userType.Field(0).Tag.Get("json")
  fmt.Println(jsonString)  //user_name
}

以上这篇浅谈Go语言中的结构体struct & 接口Interface & 反射就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持我.

最后此篇关于浅谈Go语言中的结构体struct 反射的文章就讲到这里了,如果你想了解更多关于浅谈Go语言中的结构体struct 反射的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

30 4 0
文章推荐： 利用Golang解析json数据的方法示例
文章推荐： golang中单向channel的语法介绍
文章推荐： Golang多线程刷票的实现代码
文章推荐： Lua游戏开发教程之时区问题详解
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com