Go語言學習筆記（四）結構體struct & 接口Interface & 反射reflect

時間  2019-11-13
標籤 語言 學習 筆記 結構 struct 接口 interface 反射 reflect 简体版
原文   原文鏈接

加 Golang學習 QQ羣共同窗習進步成家立業工做 ^-^ 羣號：96933959golang

結構體struct

struct 用來自定義複雜數據結構，能夠包含多個字段（屬性），能夠嵌套；json

go中的struct類型理解爲類，能夠定義方法，和函數定義有些許區別；數據結構

struct類型是值類型。ide

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爲指針類型，訪問的時候編譯器會自動把 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)                    //{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沒有構造函數，能夠僞造一個佈局

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 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。this

方法的訪問控制也是經過大小寫控制。spa

init函數是經過傳入指針實現，這樣改變struct字段值，由於是值類型。debug

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 stirng
    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)    //{{ 18} { 0 {0 0 <nil>}} nick 0}
}

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 int
var 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) // <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個接口的方法。

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

type Used interface {
    Car
    Cheap()
}

類型斷言

類型斷言，因爲接口是通常類型，不知道具體類型，

若是要轉成具體類型，能夠採用如下方法進行轉換：

var t int
var x interface{}
x = t

y = x.(int)       //轉成int
y, ok = x.(int)   //轉成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)
}

栗子二：

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

栗子三：

判斷一個變量是否實現了指定接口

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.Kind()方法返回的常量 
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.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) 。

//錯誤代碼！！！
//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
}

 

反射操做結構體

  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 = 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大寫
}

 

栗子三（struct tag 內部實現）

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
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程