biuaxia

package main

import (
	"fmt"
	"reflect"
)

func reflectType(x interface{}) {
	v := reflect.TypeOf(x)
	fmt.Printf("type:%v\n", v)
}
func main() {
	var a float32 = 3.14
	reflectType(a) // type:float32
	var b int64 = 100
	reflectType(b) // type:int64
}

package main

import (
	"fmt"
	"reflect"
)

type myInt int64

func reflectType(x interface{}) {
	t := reflect.TypeOf(x)
	fmt.Printf("type:%v kind:%v\n", t.Name(), t.Kind())
}

func main() {
	var a *float32 // ポインタ
	var b myInt    // カスタム型
	var c rune     // 型エイリアス
	reflectType(a) // type: kind:ptr
	reflectType(b) // type:myInt kind:int64
	reflectType(c) // type:int32 kind:int32

	type person struct {
		name string
		age  int
	}
	type book struct{ title string }
	var d = person{
		name: "沙河小王子",
		age:  18,
	}
	var e = book{title: "《小王子からGo言語を学ぶ》"}
	reflectType(d) // type:person kind:struct
	reflectType(e) // type:book kind:struct
}

type Kind uint
const (
    Invalid Kind = iota  // 無効な型
    Bool                 // ブール型
    Int                  // 符号付き整数型
    Int8                 // 符号付き8ビット整数型
    Int16                // 符号付き16ビット整数型
    Int32                // 符号付き32ビット整数型
    Int64                // 符号付き64ビット整数型
    Uint                 // 符号なし整数型
    Uint8                // 符号なし8ビット整数型
    Uint16               // 符号なし16ビット整数型
    Uint32               // 符号なし32ビット整数型
    Uint64               // 符号なし64ビット整数型
    Uintptr              // ポインタ
    Float32              // 単精度浮動小数点数
    Float64              // 倍精度浮動小数点数
    Complex64            // 64ビット複素数型
    Complex128           // 128ビット複素数型
    Array                // 配列
    Chan                 // チャンネル
    Func                 // 関数
    Interface            // インターフェース
    Map                  // マップ
    Ptr                  // ポインタ
    Slice                // スライス
    String               // 文字列
    Struct               // 構造体
    UnsafePointer        // 基底ポインタ
)

func reflectValue(x interface{}) {
	v := reflect.ValueOf(x)
	k := v.Kind()
	switch k {
	case reflect.Int64:
		// v.Int()からリフレクションで整数型の元の値を取得し、int64()で強制的に型変換
		fmt.Printf("type is int64, value is %d\n", int64(v.Int()))
	case reflect.Float32:
		// v.Float()からリフレクションで浮動小数点型の元の値を取得し、float32()で強制的に型変換
		fmt.Printf("type is float32, value is %f\n", float32(v.Float()))
	case reflect.Float64:
		// v.Float()からリフレクションで浮動小数点型の元の値を取得し、float64()で強制的に型変換
		fmt.Printf("type is float64, value is %f\n", float64(v.Float()))
	}
}
func main() {
	var a float32 = 3.14
	var b int64 = 100
	reflectValue(a) // type is float32, value is 3.140000
	reflectValue(b) // type is int64, value is 100
	// int型の元の値をreflect.Value型に変換
	c := reflect.ValueOf(10)
	fmt.Printf("type c :%T\n", c) // type c :reflect.Value
}

package main

import (
	"fmt"
	"reflect"
)

func reflectSetValue1(x interface{}) {
	v := reflect.ValueOf(x)
	if v.Kind() == reflect.Int64 {
		v.SetInt(200) // 変更されるのはコピーであり、reflectパッケージはpanicを引き起こします
	}
}
func reflectSetValue2(x interface{}) {
	v := reflect.ValueOf(x)
	// リフレクションではElem()メソッドを使用してポインタに対応する値を取得
	if v.Elem().Kind() == reflect.Int64 {
		v.Elem().SetInt(200)
	}
}
func main() {
	var a int64 = 100
	// reflectSetValue1(a) //panic: reflect: reflect.Value.SetInt using unaddressable value
	reflectSetValue2(&a)
	fmt.Println(a)
}

func (v Value) IsNil() bool

func (v Value) IsValid() bool

func main() {
	// *int型の空ポインタ
	var a *int
	fmt.Println("var a *int IsNil:", reflect.ValueOf(a).IsNil())
	// nil値
	fmt.Println("nil IsValid:", reflect.ValueOf(nil).IsValid())
	// 匿名構造体をインスタンス化
	b := struct{}{}
	// 構造体から"abc"フィールドを探そうとする
	fmt.Println("存在しない構造体メンバー:", reflect.ValueOf(b).FieldByName("abc").IsValid())
	// 構造体から"abc"メソッドを探そうとする
	fmt.Println("存在しない構造体メソッド:", reflect.ValueOf(b).MethodByName("abc").IsValid())
	// マップ
	c := map[string]int{}
	// マップから存在しないキーを探そうとする
	fmt.Println("map中存在しないキー：", reflect.ValueOf(c).MapIndex(reflect.ValueOf("娜扎")).IsValid())
}

type StructField struct {
    // Nameはフィールドの名前です。PkgPathは非エクスポートフィールドのパッケージパスで、エクスポートフィールドの場合はこのフィールドは""です。
    // 参照：http://golang.org/ref/spec#Uniqueness_of_identifiers
    Name    string
    PkgPath string
    Type      Type      // フィールドの型
    Tag       StructTag // フィールドのタグ
    Offset    uintptr   // フィールドが構造体内でのバイトオフセット
    Index     []int     // Type.FieldByIndex時のインデックススライス
    Anonymous bool      // 匿名フィールドかどうか
}

type student struct {
	Name  string `json:"name"`
	Score int    `json:"score"`
}

func main() {
	stu1 := student{
		Name:  "小王子",
		Score: 90,
	}

	t := reflect.TypeOf(stu1)
	fmt.Println(t.Name(), t.Kind()) // student struct
	// forループを使用して構造体のすべてのフィールド情報を反復処理
	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)
		fmt.Printf("name:%s index:%d type:%v json tag:%v\n", field.Name, field.Index, field.Type, field.Tag.Get("json"))
	}

	// フィールド名を通じて指定された構造体フィールド情報を取得
	if scoreField, ok := t.FieldByName("Score"); ok {
		fmt.Printf("name:%s index:%d type:%v json tag:%v\n", scoreField.Name, scoreField.Index, scoreField.Type, scoreField.Tag.Get("json"))
	}
}

// studentに二つのメソッドStudyとSleepを追加（注意：大文字で始まる）
func (s student) Study() string {
	msg := "しっかり勉強して、毎日向上しましょう。"
	fmt.Println(msg)
	return msg
}

func (s student) Sleep() string {
	msg := "しっかり寝て、早く成長しましょう。"
	fmt.Println(msg)
	return msg
}

func printMethod(x interface{}) {
	t := reflect.TypeOf(x)
	v := reflect.ValueOf(x)

	fmt.Println(t.NumMethod())
	for i := 0; i < v.NumMethod(); i++ {
		methodType := v.Method(i).Type()
		fmt.Printf("method name:%s\n", t.Method(i).Name)
		fmt.Printf("method:%s\n", methodType)
		// リフレクションを通じてメソッドを呼び出す際、引数は[]reflect.Value型で渡す必要があります
		var args = []reflect.Value{}
		v.Method(i).Call(args)
	}
}