Lixv

A := 10 // a の型は int で、値は 10 です。これは Go 言語の構文糖が簡単に型を作成するのを助けています。
var a int = 10 // 実際にはこのように作成すべきで、値を宣言する際に型を明示します。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var num int = 42
	var str string = "Hello, Reflect!"

	fmt.Println(reflect.TypeOf(num))  // 出力: int
	fmt.Println(reflect.TypeOf(str))  // 出力: string
}

	var a myFloat64 // カスタム型
	var b *float64  // ポインタ

	reflectType(a) // 出力：TypeOf: main.myFloat64, 型：myFloat64, 種類：float64
	reflectType(b) // 出力：TypeOf: *float64, 型：, 種類：ptr

	type Person struct {
		Name string
		Age  int
	}
	var p = Person{
		Name: "Lixin",
		Age:  21,
	}
	reflectType(p) // TypeOf: TypeOf: main.Person, 型：Person, 種類：struct

// go reflect 標準ライブラリのソースコード
// A Kind は、Type が表す特定の型の種類を表します。
// ゼロ Kind は有効な種類ではありません。
type Kind uint

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
	Pointer
	Slice
	String
	Struct
	UnsafePointer
)

package main

import (
	"fmt"
	"reflect"
)

func main() {
	// reflect.ValueOf を使用して reflect.Value を取得
	v := reflect.ValueOf(42)

	// 原始値を取得
	value := v.Interface()
	fmt.Println(value) // 出力: 42

	// 型アサーションを使用して原始値を具体的な型に変換
	if i, ok := value.(int); ok {
		fmt.Println(i * 2) // 出力: 84
	}

	// 他のメソッドを使用して原始値を取得
	b := reflect.ValueOf(true).Bool()
	fmt.Println(b) // 出力: true

	f := reflect.ValueOf(3.14).Float()
	fmt.Println(f) // 出力: 3.14

	s := reflect.ValueOf("hello").String()
	fmt.Println(s) // 出力: hello

	t := reflect.ValueOf(42).Type()
	fmt.Println(t) // 出力: int
}

package main

import (
	"fmt"
	"reflect"
)

type Person struct {
	Name string
	Age  int
}

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

	// 反射を使用して変数のポインタ値を取得
	// ここではポインタでなければならず、底層ポインタを通じて値を変更するためです
	v := reflect.ValueOf(&p)

	// ポインタ型であり、アドレス可能かどうかを確認
	if v.Kind() == reflect.Ptr && v.Elem().CanSet() {
		// ポインタが指す値を取得
		elem := v.Elem()

		// フィールドの値を取得し、変更
		nameField := elem.FieldByName("Name")
		if nameField.IsValid() && nameField.Kind() == reflect.String {
			nameField.SetString("Bob")
		}

		ageField := elem.FieldByName("Age")
		if ageField.IsValid() && ageField.Kind() == reflect.Int {
			ageField.SetInt(30)
		}
	}

	fmt.Printf("%+v", p) // 出力: {Name:Bob Age:30}
}

package main

import (
	"fmt"
	"reflect"
)

type Person struct {
	Name string
	Age  int
}

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

package main

import (
	"fmt"
	"reflect"
)

type Person struct {
	Name   string
	Age    int
	Height float64
}

func (p Person) SayHello() {
	fmt.Println("Hello, my name is", p.Name)
}

func main() {
	p := Person{
		Name:   "John",
		Age:    30,
		Height: 1.75,
	}

	// 構造体フィールド情報を取得
	t := reflect.TypeOf(p)
	fmt.Println("構造体フィールド:")
	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)
		fmt.Printf("名前: %s, 型: %s\n", field.Name, field.Type)
	}

	// フィールド名に基づいて構造体フィールド情報を取得
	field, ok := t.FieldByName("Age")
	if ok {
		fmt.Println("\n名前によるフィールド:")
		fmt.Printf("名前: %s, 型: %s\n", field.Name, field.Type)
	}

	// 構造体メソッド情報を取得
	v := reflect.ValueOf(p)
	fmt.Println("\nメソッド:")
	for i := 0; i < t.NumMethod(); i++ {
		method := t.Method(i)
		fmt.Printf("名前: %s, 型: %s\n", method.Name, method.Type)
	}

	// メソッド名に基づいて構造体メソッド情報を取得
	method, ok := t.MethodByName("SayHello")
	if ok {
		fmt.Println("\n名前によるメソッド:")
		fmt.Printf("名前: %s, 型: %s\n", method.Name, method.Type)
	}
}

// 出力
構造体フィールド:
名前: Name, 型: string
名前: Age, 型: int
名前: Height, 型: float64

名前によるフィールド:
名前: Age, 型: int

メソッド:
名前: SayHello, 型: func(main.Person)

名前によるメソッド:
名前: SayHello, 型: func(main.Person)

package main

import (
	"fmt"
	"net/http"
	"reflect"
	"strings"
)

type Service struct{}

func (s *Service) Get_Hubs(w http.ResponseWriter, r *http.Request) {
	fmt.Println("Handling GET request for /hubs")
}

func (s *Service) Post_Name(w http.ResponseWriter, r *http.Request) {
	fmt.Println("Handling POST request for /name")
}

func RegisterHTTPHandlers(service interface{}) {
	svcType := reflect.TypeOf(service)
	svcValue := reflect.ValueOf(service)

	for i := 0; i < svcType.NumMethod(); i++ {
		method := svcType.Method(i)
		methodName := method.Name

		if strings.HasPrefix(methodName, "Get_") || strings.HasPrefix(methodName, "Post_") {
			parts := strings.Split(methodName, "_")
			if len(parts) < 2 {
				continue
			}

			path := "/" + strings.ToLower(strings.Join(parts[1:], "/"))
			handler := svcValue.MethodByName(methodName).Interface().(func(http.ResponseWriter, *http.Request))
			http.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
				switch r.Method {
				case http.MethodGet:
					if strings.HasPrefix(methodName, "Get_") {
						handler(w, r)
					} else {
						http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
					}
				case http.MethodPost:
					if strings.HasPrefix(methodName, "Post_") {
						handler(w, r)
					} else {
						http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
					}
				default:
					http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
				}
			})
		}
	}
}

func main() {
	service := &Service{}
	RegisterHTTPHandlers(service)

	fmt.Println("Listening on http://localhost:8889")
	http.ListenAndServe(":8889", nil)
}

Listening on http://localhost:8889
Handling POST request for /name
Handling GET request for /hubs