Golang 如何在运行时检查变量类型？

In Go, runtime type checking of variables is primarily achieved using the reflect package. This package enables inspecting, reading, and modifying the types and values of objects without requiring prior knowledge of these details at compile time.

Here's a basic example using the reflect package to check variable types:

go
package main

import (
	"fmt"
	"reflect"
)

func main() {
	var x float64 = 3.4
	fmt.Println("type:", reflect.TypeOf(x))  // Output the variable's type

	v := reflect.ValueOf(x)
	fmt.Println("type:", v.Type())          // Retrieve type from reflect.Value
	fmt.Println("kind is float64:", v.Kind() == reflect.Float64) // Verify kind
}

In this example, the reflect.TypeOf() function retrieves the variable's type, while the v.Kind() method returns the specific type kind (e.g., reflect.Float64, reflect.Int, etc.). By comparing these kind values, we can determine the exact type of the variable.

Additionally, for handling interfaces or unknown types, type assertions are used to check and convert types:

go
package main

import (
	"fmt"
)

func main() {
	var i interface{} = "hello"

	s, ok := i.(string)
	fmt.Println(s, ok)  // Output: hello true

	f, ok := i.(float64)
	fmt.Println(f, ok)  // Output: 0 false

	if s, ok := i.(string); ok {
		fmt.Println(s)  // Output if i is string type
	}

	switch v := i.(type) {
	case string:
		fmt.Println("Variable is a string:", v)
	case float64:
		fmt.Println("Variable is a float64:", v)
	default:
		fmt.Println("Unknown type")
	}
}

Here, i.(type) is a type assertion used to detect and convert the actual type stored within interface{}. Leveraging the type switch feature of the switch statement, it facilitates performing different operations based on the type.

Through these approaches, Golang provides a flexible mechanism for runtime type checking and conversion.