golang結構體、介面、反射

struct結構體

• struct用來自訂複雜資料結構，可以包含多個欄位屬性，可以嵌套;
• go中的struct類型理解為類，可以定義方法，和函數定義有些許區別;
• struct類型是實值型別.

struct定義

type User struct {    Name string    Age int32    mess string}var user Uservar user1 *User = &User{}// new 會分配結構空間，並初始化為清空為零，不進一步初始化// new之後需要一個指標來指向這個結構// make會分配結構空間及其附屬空間，並完成其間的指標初始化// make返回這個結構空間，不另外分配一個指標var user2 *User = new(User)

struct使用

下面樣本中user1和uesr2為指標類型，訪問的時候編譯器會自動把user1.Name轉為(*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)    fmt.Println(user1.Name,(*user1).Name)        var user2 *User = new(User)    user2.Name = "suoning"}

建構函式

golang中的struct沒有建構函式，可以偽造一個

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中的所有欄位在記憶體是連續的，布局如下:

var user Useruser.Name = "nick"user.Age = 18user.mess = "lover"fmt.Println(user)fmt.Printf("Name:%p\n", &user.Name)fmt.Printf("Age: %p\n", &user.Age)fmt.Printf("mess: %p\n",&user.mess)

方法

方法是作用在特定類型的變數上，因此自訂類型，都可以有方法，而不僅僅是struct。
方法的存取控制也是通過大小控制。
init函數是通過傳入指標實現，這樣改變struct欄位值，因為是實值型別.

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

匿名欄位

如果有衝突的，則最外的優先

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

繼承 & 多重繼承

一個結構全繼承多個結構體，訪問通過點。繼承欄位以及方法
可以起別名，如下面u1(user1),訪問user.u1.Age。
如果繼承的結構全都擁有同一個欄位，通過user.name訪問就會報錯，必須通過user.user1.name來訪問.

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

tag

在go中，首字母大小寫有特殊的文法含義，小寫包外無法引用。由於需要和其它的系統進行資料互動，例如轉成json格式。
這個時候如果用屬性名稱來作為索引值可能不一定會符合項目要求。tag在轉換成其它資料格式的時候，會使用其中特定的欄位作為索引值.

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

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

defer所有錯誤

func myE() (str string, err error) {    defer func() {        if p := recover(); p != nil {            str, ok := p.(string)            if ok {                err = errors.New(str)            } else {                err = errors.New("panic")            }            // debug.PrintStack()        }    }()    panic("this is panic message")    return "hello girl",err}

介面interface

interface類型可以定義一組方法，但是這些不需要實現。並interface不能包含任何變數.
interface類型預設是一個指標.

Interface定義

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

Interface實現

• 1.Golang中的介面，不需要顯示的實現。只要一個變數，含有介面類型中的所有方法，那麼這個變數就實現這個介面。因此golang中沒有implement類似的關鍵字；
• 2.如果一個變數含有了多個interface類型的方法，那麼這個變數就實現了多個介面；如果一個變數只含有了1個interface的方部分方法，那麼這個變數沒有實現這個介面。
• 3.空介面interface{}: 空介面沒有任何方法，所以所有類型都實現了空介面。

var a intvar b interface{}    // 空介面b = a

多態

一種事物的多種形態，都可以按照統一的介面進行操作。
例子:

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)        var bmw BMW = BMW{Name: "寶馬"}    car = &bmw    fmt.Println(car.NameGet())  // 寶馬    car.Run(1)    car.Stop()        benz := &Benz{Name: "大奔"}    car = benz    fmt.Println(car.NameGet())  // 大奔    car.Run(2)    car.Stop()}

Interface嵌套

一個接可以嵌套在另外的介面
即需要實現2個介面的方法。

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

類型斷言

類型斷言,由於介面是一般類型，不知道具體類型，
如果要轉成具體類型，可以採用以下方法進行轉換:

var t intvar x interface{}x = ty = x.(int)y, ok = x.(int)

例子一

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

例子二

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

例子三

判斷一個變數是否實現了指定介面

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擷取變數的類別，返回一個常量

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.Interface()轉換成interface{}類型【變數<-->Interface{}<--->Reflect.Value】

擷取變數的值

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

通過反射的來改變變數的值

reflect.Value.SetXX相關方法，比如:reflect.Value.SetInt(),設定整數reflect.Value.SetFloat(),設定浮點數reflect.Value.SetString(),設定字串

例子一

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.Println("value is %1.1e\n", v.Interface())  // value is 5.2e+00    y := v.Interface().(float64)    fmt.Println(y)}

例子二(修改值)

setXX(x)因為傳遞的是x的值的副本，所以SetXX不能夠改x,改動x必須向函數傳遞x的指標，
SetXX(&x)

// 錯誤碼// panic: reflect: reflect.Value.SetFloat using unaddressable valuefunc main() {    var a float64    fv := reflect.ValueOf(&a)    fv.SetFloat(520.00)    fmt.Printf("%v\n",a)}

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

反射操作結構體

• 1.reflect.Value.NumField() 擷取結構體中欄位的個數
• 2.reflect.Value.Method(n).Call(nil) 來調用結構體中的方法

例子一(通過反射操作結構體)

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

例子二(通過反射修改結構體)

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 = 181: 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)    fmt.Println(val.Elem())    fmt.Println(val.Elem().Field(0))    val.Elem().Field(0).SetString("hehe")}

例子三(struct tag內部實現)

package mainimport (    "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)}