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: 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 represents the specific kind of type that a Type represents.
// The zero Kind is not a valid 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
	// map
	c := map[string]int{}
	// 嘗試從map中查找一個不存在的鍵
	fmt.Println("map中不存在的鍵：", reflect.ValueOf(c).MapIndex(reflect.ValueOf("娜扎")).IsValid()) // map中不存在的鍵： 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("Struct fields:")
	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)
		fmt.Printf("Name: %s, Type: %s\n", field.Name, field.Type)
	}

	// 根據字段名獲取結構體字段信息
	field, ok := t.FieldByName("Age")
	if ok {
		fmt.Println("\nField by name:")
		fmt.Printf("Name: %s, Type: %s\n", field.Name, field.Type)
	}

	// 獲取結構體方法信息
	v := reflect.ValueOf(p)
	fmt.Println("\nMethods:")
	for i := 0; i < t.NumMethod(); i++ {
		method := t.Method(i)
		fmt.Printf("Name: %s, Type: %s\n", method.Name, method.Type)
	}

	// 根據方法名獲取結構體方法信息
	method, ok := t.MethodByName("SayHello")
	if ok {
		fmt.Println("\nMethod by name:")
		fmt.Printf("Name: %s, Type: %s\n", method.Name, method.Type)
	}
}

// 輸出
Struct fields:
Name: Name, Type: string
Name: Age, Type: int
Name: Height, Type: float64

Field by name:
Name: Age, Type: int

Methods:
Name: SayHello, Type: func(main.Person)

Method by name:
Name: SayHello, Type: 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