淺談Go語(yǔ)言中的結(jié)構(gòu)體struct & 接口Interface & 反射

更新時(shí)間：2017年07月26日 08:08:03 投稿：jingxian

下面小編就為大家?guī)?lái)一篇淺談Go語(yǔ)言中的結(jié)構(gòu)體struct & 接口Interface & 反射。小編覺(jué)得挺不錯(cuò)的，現(xiàn)在就分享給大家，也給大家做個(gè)參考。一起跟隨小編過(guò)來(lái)看看吧

結(jié)構(gòu)體struct

struct 用來(lái)自定義復(fù)雜數(shù)據(jù)結(jié)構(gòu)，可以包含多個(gè)字段（屬性），可以嵌套；

go中的struct類型理解為類，可以定義方法，和函數(shù)定義有些許區(qū)別；

struct類型是值類型。

struct定義

type User struct {
 Name string
 Age int32
 mess string
}

var user User
var user1 *User = &User{}
var user2 *User = new(User)

struct使用

下面示例中user1和user2為指針類型，訪問(wèn)的時(shí)候編譯器會(huì)自動(dòng)把 user1.Name 轉(zhuǎn)為 (*user1).Name

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
}

構(gòu)造函數(shù)

golang中的struct沒(méi)有構(gòu)造函數(shù)，可以偽造一個(gè)

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

內(nèi)存布局

struct中的所有字段在內(nèi)存是連續(xù)的

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字節(jié)為內(nèi)存對(duì)齊

方法

方法是作用在特定類型的變量上，因此自定義類型，都可以有方法，而不僅僅是struct。

方法的訪問(wèn)控制也是通過(guò)大小寫(xiě)控制。

init函數(shù)是通過(guò)傳入指針實(shí)現(xiàn)，這樣改變struct字段值，因?yàn)槭侵殿愋汀?/p>

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

匿名字段

如果有沖突的，則最外的優(yōu)先

type User struct {
 Name stirng
 Age int  
}

type Lover struct {
  User
  sex time.Time
  int
  Age int
}

繼承 & 多重繼承

一個(gè)結(jié)構(gòu)體繼承多個(gè)結(jié)構(gòu)體，訪問(wèn)通過(guò)點(diǎn)。繼承字段以及方法。

可以起別名，如下面 u1（user1），訪問(wèn) user.u1.Age。

如果繼承的結(jié)構(gòu)體都擁有同一個(gè)字段，通過(guò)user.name訪問(wèn)就會(huì)報(bào)錯(cuò)，必須通過(guò)user.user1.name來(lái)訪問(wèn)。

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中，首字母大小寫(xiě)有特殊的語(yǔ)法含義，小寫(xiě)包外無(wú)法引用。由于需要和其它的系統(tǒng)進(jìn)行數(shù)據(jù)交互，例如轉(zhuǎn)成json格式。這個(gè)時(shí)候如果用屬性名來(lái)作為鍵值可能不一定會(huì)符合項(xiàng)目要求。tag在轉(zhuǎn)換成其它數(shù)據(jù)格式的時(shí)候，會(huì)使用其中特定的字段作為鍵值。

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()

如果實(shí)現(xiàn)了String()這個(gè)方法，那么fmt默認(rèn)會(huì)調(diào)用String()。

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類型可以定義一組方法，但是這些不需要實(shí)現(xiàn)。并且interface不能包含任何變量。

interface類型默認(rèn)是一個(gè)指針。

Interface定義

type Car interface {
 NameGet() string
 Run(n int)
 Stop()
}

Interface實(shí)現(xiàn)

Golang中的接口，不需要顯示的實(shí)現(xiàn)。只要一個(gè)變量，含有接口類型中的所有方法，那么這個(gè)變量就實(shí)現(xiàn)這個(gè)接口。因此，golang中沒(méi)有implement類似的關(guān)鍵字；

如果一個(gè)變量含有了多個(gè)interface類型的方法，那么這個(gè)變量就實(shí)現(xiàn)了多個(gè)接口；如果一個(gè)變量只含有了1個(gè)interface的方部分方法，那么這個(gè)變量沒(méi)有實(shí)現(xiàn)這個(gè)接口。

空接口 Interface{}：空接口沒(méi)有任何方法，所以所有類型都實(shí)現(xiàn)了空接口。

var a int
var b interface{} //空接口
b = a

多態(tài)

一種事物的多種形態(tài)，都可以按照統(tǒng)一的接口進(jìn)行操作。

栗子：

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嵌套

一個(gè)接口可以嵌套在另外的接口。

即需要實(shí)現(xiàn)2個(gè)接口的方法。

type Car interface {
 NameGet() string
 Run(n int)
 Stop()
}

type Used interface {
 Car
 Cheap()
}

類型斷言

類型斷言，由于接口是一般類型，不知道具體類型，

如果要轉(zhuǎn)成具體類型，可以采用以下方法進(jìn)行轉(zhuǎn)換：

var t int
var x interface{}
x = t

y = x.(int)  //轉(zhuǎn)成int
y, ok = x.(int) //轉(zhuǎn)成int，不報(bào)錯(cuò)

栗子一：

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

栗子二：

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

栗子三：

判斷一個(gè)變量是否實(shí)現(xiàn)了指定接口

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包實(shí)現(xiàn)了運(yùn)行時(shí)反射，允許程序操作任意類型的對(duì)象。

典型用法是用靜態(tài)類型interface{}保存一個(gè)值，

　　通過(guò)調(diào)用TypeOf獲取其動(dòng)態(tài)類型信息，該函數(shù)返回一個(gè)Type類型值。

　　調(diào)用ValueOf函數(shù)返回一個(gè)Value類型值，該值代表運(yùn)行時(shí)的數(shù)據(jù)。

func TypeOf(i interface{}) Type

TypeOf返回接口中保存的值的類型，TypeOf(nil)會(huì)返回nil。

func ValueOf(i interface{}) Value

ValueOf返回一個(gè)初始化為i接口保管的具體值的Value，ValueOf(nil)返回Value零值。

reflect.Value.Kind

獲取變量的類別，返回一個(gè)常量

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()

轉(zhuǎn)換成interface{}類型

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

獲取變量的值：

reflect.ValueOf(x).Int()
reflect.ValueOf(x).Float() 
reflect.ValueOf(x).String()
reflect.ValueOf(x).Bool()

通過(guò)反射的來(lái)改變變量的值

reflect.Value.SetXX相關(guān)方法，比如:
reflect.Value.SetInt()，設(shè)置整數(shù)
reflect.Value.SetFloat()，設(shè)置浮點(diǎn)數(shù)
reflect.Value.SetString()，設(shè)置字符串

栗子一

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) 因?yàn)閭鬟f的是 x 的值的副本，所以SetXX不能夠改 x，改動(dòng) x 必須向函數(shù)傳遞 x 的指針，SetXX(&x) 。

//錯(cuò)誤代碼！?。?
//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)
}

//正確的，傳指針
func main() {
 var a2 float64
 fv2 := reflect.ValueOf(&a2)
 fv2.Elem().SetFloat(520.00)
 fmt.Printf("%v\n", a2) //520
}

反射操作結(jié)構(gòu)體

reflect.Value.NumField()獲取結(jié)構(gòu)體中字段的個(gè)數(shù)

reflect.Value.Method(n).Call(nil)來(lái)調(diào)用結(jié)構(gòu)體中的方法

栗子一（通過(guò)反射操作結(jié)構(gòu)體）

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]
}

栗子二（通過(guò)反射修改結(jié)構(gòu)體）

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

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大寫(xiě)
}

栗子三（struct tag 內(nèi)部實(shí)現(xiàn)）

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語(yǔ)言中的結(jié)構(gòu)體struct & 接口Interface & 反射就是小編分享給大家的全部?jī)?nèi)容了，希望能給大家一個(gè)參考，也希望大家多多支持腳本之家。

您可能感興趣的文章: