var name string // string是靜態(tài)類型的
var age int  // int 是靜態(tài)類型的

var A interface{}   // interface{} 靜態(tài)類型 

A = 10              // interface{} 靜態(tài)類型   此時的A是動態(tài)類型 int
A = "jingtian"   // interface{} 靜態(tài)類型   此時的A是動態(tài)類型 string

package main

import (
    "fmt"
    "reflect"
)

// 反射
/*
Type : reflect.TypeOf(a) , 獲取變量的類型
Value ：reflect.ValueOf(a) ， 獲取變量的值
*/

func main() {
    // 正常編程定義變量
    var a int = 3
    // func TypeOf(i any) Type 反射得到該變量的數(shù)據(jù)類型
    fmt.Println("type", reflect.TypeOf(a))
    // func ValueOf(i any) Value  反射得到該變量的值
    fmt.Println("value", reflect.ValueOf(a))

    // 根據(jù)反射的值，來獲取對象對應(yīng)的類型和數(shù)值
    // 如果我們不知道這個對象的信息，我們可以通過這個對象拿到代碼中的一切。
    // 獲取a的類型
    v := reflect.ValueOf(a) // string int User
    // Kind : 獲取這個值的種類， 在反射中，所有數(shù)據(jù)類型判斷都是使用種類。
    //根據(jù)kind來判斷其類型
    if v.Kind() == reflect.Float64 {
        fmt.Println(v.Float())
    }
    if v.Kind() == reflect.Int {
        fmt.Println(v.Int())
    }
    fmt.Println(v.Kind() == reflect.Float64)
    //fmt.Println(v.Type())

}

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
)

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    jsonStr := `{"id":1, "name":"jigntian", "age":18}`
    var user User
    // func Unmarshal(data []byte, v any) error
    //先解析，看是否報錯，要是報錯，給的就不是json字符串
    err := json.Unmarshal([]byte(jsonStr), &user)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    // 使用反射獲取User結(jié)構(gòu)體的字段信息
    val := reflect.ValueOf(user)
    typ := reflect.TypeOf(user)

    for i := 0; i < val.NumField(); i++ {
        fieldVal := val.Field(i)
        fieldType := typ.Field(i)
        fmt.Printf("Field Name: %s, Field Value: %v, Field Type: %s\n", fieldType.Name, fieldVal, fieldType.Type)
    }
}

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    var p Person = Person{Name: "Alice", Age: 30}

    // 獲取類型信息
    t := reflect.TypeOf(p)

    // 打印類型名稱
    fmt.Println("Type name:", t.Name())

    // 打印類型種類
    fmt.Println("Type kind:", t.Kind())

    // 打印結(jié)構(gòu)體字段信息
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        fmt.Printf("Field name: %s, Field type: %s\n", field.Name, field.Type)
    }
}

package main

import (
    "fmt"
    "reflect"
)

type User5 struct {
    Name string
    Age  int
    Sex  string
}

func (user User5) Say(msg string) {
    fmt.Println("User 說：", msg)
}

// PrintInfo  打印結(jié)構(gòu)體信息
func (user User5) PrintInfo() {
    fmt.Printf("姓名：%s，年齡：%d，性別：%s\n", user.Name, user.Age, user.Sex)
}

func main() {
    user := User5{"jingtian", 18, "男"}

    reflectGetInfo(user)
}

// 通過反射，獲取變量的信息
func reflectGetInfo(v interface{}) {
    // 1、獲取參數(shù)的類型Type , 可能是用戶自己定義的，但是Kind一定是內(nèi)部類型struct
    getType := reflect.TypeOf(v)
    fmt.Println(getType.Name()) // 類型信息 User5
    fmt.Println(getType.Kind()) // 找到上級的種類Kind  struct

    // 2、獲取值
    getValue := reflect.ValueOf(v)
    //查看類型 Type得到的是我們自定義的類型main.User5   Kind得到的是go內(nèi)置的類型 struct
    fmt.Println("獲取到的value--type值類型", getValue.Type()) // main.User5
    fmt.Println("獲取到的value--kind值類型", getValue.Kind()) // struct
    fmt.Println("獲取到value", getValue)

    // 獲取字段，通過Type扒出字段
    // Type.NumField() 獲取這個類型中有幾個字段  3
    // field(index) 得到字段的值
    for i := 0; i < getType.NumField(); i++ {
        field := getType.Field(i) // 類型
        //通過valueof.Field().Interface拿到值
        value := getValue.Field(i).Interface() // value
        // 打印
        fmt.Printf("字段名：%s,字段類型：%s，字段值：%v\n", field.Name, field.Type, value)
    }

    // 獲取這個結(jié)構(gòu)體的方法 , NumMethod 可以獲取方法的數(shù)量
    for i := 0; i < getType.NumMethod(); i++ {
        method := getType.Method(i)
        fmt.Printf("方法的名字：%s\t,方法類型：%s", method.Name, method.Type)
        //執(zhí)行方法
        //method.Name()
    }

}

/*
由上面反射，就可以推導(dǎo)出結(jié)構(gòu)體字段以及其方法
type User struct{
   Name string
   Age int
   Sex string
}
func (main.User) PrintInfo(){}
func (main.User) Say(string)
*/

package main

import (
    "fmt"
    "reflect"
)

type Person3 struct {
    Name string
    Age  int
}

func main() {
    var p Person3 = Person3{Name: "jingtian", Age: 18}

    // 獲取值信息
    v := reflect.ValueOf(p)

    // 打印值信息
    fmt.Println("Value of Name:", v.FieldByName("Name").String())
    fmt.Println("Value of Age:", v.FieldByName("Age").Int())

    // 修改結(jié)構(gòu)體字段值（注意：這里只是演示，實際上無法直接修改，因為v是不可變的）
    // 要修改值，需要使用reflect.ValueOf的Elem方法配合指針變量
    // 下面的代碼會報錯：panic: reflect: call of reflect.Value.SetInt on zero Value
    // v.FieldByName("Age").SetInt(35)

    // 正確的修改方式
    pv := reflect.ValueOf(&p).Elem() // 獲取指針指向的元素的值
    pv.FieldByName("Age").SetInt(35) // 修改字段值

    // 打印修改后的值
    fmt.Println("Modified Age:", p.Age)
}

package main

import (
    "fmt"
    "reflect"
)

// 反射設(shè)置變量的值
func main() {

    var num float64 = 3.14
    update(&num)  //注意，這里傳入指針地址
    fmt.Println(num)

}

func update(v any) {
    // 通過反射修改值,需要操作對象的指針，拿到地址，然后拿到指針對象
    pointer := reflect.ValueOf(v)
    newValue := pointer.Elem()

    fmt.Println("類型：", newValue.Type())
    fmt.Println("判斷該類型是否可以修改：", newValue.CanSet())

    // 通過反射對象給變量賦值
    //newValue.SetFloat(999.43434)
    // 也可以對類型進(jìn)行判斷，根據(jù)不同類型修改成不同的值

    if newValue.Kind() == reflect.Float64 {
        // 通過反射對象給變量賦值
        newValue.SetFloat(2.21)
    }
    if newValue.Kind() == reflect.Int {
        // 通過反射對象給變量賦值
        newValue.SetInt(2)
    }
}

package main

import (
    "fmt"
    "reflect"
)

type Person4 struct {
    Name string
    Age  int
}

// 反射設(shè)置變量的值
func main() {

    person := Person4{"jingtian", 18}
    //注意，這里傳入指針
    update2(&person)
    fmt.Println(person)

}

func update2(v any) {
    // 通過反射修改值,需要操作對象的指針，拿到地址，然后拿到指針對象
    pointer := reflect.ValueOf(v)
    newValue := pointer.Elem()

    fmt.Println("類型：", newValue.Type())
    fmt.Println("判斷該類型是否可以修改：", newValue.CanSet())

    //修改結(jié)構(gòu)體數(shù)據(jù)
    // 需要找到對象的結(jié)構(gòu)體字段名
    newValue.FieldByName("Name").SetString("王安石")
        //如果不知道字段的類型，可以判斷下
    fmt.Println("看下字段的類型", newValue.FieldByName("Name").Kind())

    newValue.FieldByName("Age").SetInt(99)

}

package main

import (
    "fmt"
    "reflect"
)

type User6 struct {
    Name string
    Age  int
    Sex  string
}

func (user User6) Say2(msg string) {
    fmt.Println(user.Name, "說：", msg)
}

// PrintInfo2  打印結(jié)構(gòu)體信息
func (user User6) PrintInfo2() {
    fmt.Printf("姓名：%s，年齡：%d，性別：%s\n", user.Name, user.Age, user.Sex)
}

func main() {
    user := User6{"景天", 18, "男"}

    // 通過方法名，找到這個方法, 然后調(diào)用 Call() 方法來執(zhí)行
    // 反射調(diào)用方法
    value := reflect.ValueOf(user)
    fmt.Printf("kind:%s,  type:%s\n", value.Kind(), value.Type())

    //根據(jù)方法名找到方法，通過call來調(diào)用方法，call里面跟參數(shù)，。無參使用nil
    // func (v Value) Call(in []Value) []Value  Call的參數(shù)是個reflect.Value類型的切片
    value.MethodByName("PrintInfo2").Call(nil) // 無參方法調(diào)用

    // 有參方法調(diào)用。先創(chuàng)建個reflect.Value類型的切片，長度為參數(shù)的個數(shù)
    args := make([]reflect.Value, 1)
    //給參數(shù)賦值
    // func ValueOf(i any) Value
    args[0] = reflect.ValueOf("這反射來調(diào)用的")
    //找到方法名，調(diào)用傳參
    value.MethodByName("Say2").Call(args) // 有參方法調(diào)用
}

package main

import (
    "fmt"
    "reflect"
)

// 反射調(diào)用函數(shù)  func
func main() {
    // 通過函數(shù)名來進(jìn)行反射  reflect.ValueOf(函數(shù)名)
    // Kind func
    value1 := reflect.ValueOf(fun1)
    fmt.Println("打印拿到的數(shù)據(jù)類型", value1.Kind(), value1.Type())
    //調(diào)用無參函數(shù)
    value1.Call(nil)

    //調(diào)用有參函數(shù)
    value2 := reflect.ValueOf(fun2)
    fmt.Println("打印有參函數(shù)", value2.Kind(), value2.Type())

    //創(chuàng)建參數(shù)
    args1 := make([]reflect.Value, 2)
    args1[0] = reflect.ValueOf(1)
    args1[1] = reflect.ValueOf("hahahhaha")
    value2.Call(args1)

    //調(diào)用有參數(shù)，有返回值函數(shù)
    vuale3 := reflect.ValueOf(fun3)
    fmt.Println(vuale3.Kind(), vuale3.Type())
    args2 := make([]reflect.Value, 2)
    args2[0] = reflect.ValueOf(2)
    args2[1] = reflect.ValueOf("hahahhaha")
    //接收返回值 返回的是切片
    // func (v Value) Call(in []Value) []Value
    resultValue := vuale3.Call(args2)
    fmt.Println("返回值：", resultValue[0])
}

// 無參函數(shù)
func fun1() {
    fmt.Println("fun1:無參")
}

// 有參函數(shù)
func fun2(i int, s string) {
    fmt.Println("fun2:有參 i=", i, " s=", s)
}

// 有返回值函數(shù)
func fun3(i int, s string) string {
    fmt.Println("fun3:有參有返回值 i=", i, " s=", s)
    return s
}