Golang 检查变量类型的四种方式

%T 格式化标识

利用 fmt 包是最为直观的查看变量类型的方式。在字符串格式化时，使用 %T 作为占位符，可以直接输出变量的 Go 语言源码级类型名称。这种方法适用于调试日志或在控制台快速确认数据类型。

package main
import (
	"fmt"
)
func main() {
	var count int = 42
	var message string = "go find type"
	var isCheck bool = true
	var amount float32 = 10.2

	// %v 显示值，%T 显示类型
	fmt.Printf("variable count=%v is of type %T \n", count, count)
	fmt.Printf("variable message='%v' is of type %T \n", message, message)
	fmt.Printf("variable isCheck='%v' is of type %T \n", isCheck, isCheck)
	fmt.Printf("variable amount=%v is of type %T \n", amount, amount)
}

注意：如果变量被存储在 interface{} 中，直接传入 %T 依然能正确解析其底层类型。

使用 reflect 包函数

当需要在代码逻辑中进行类型判断，而非仅仅打印日志时，标准库中的 reflect 包是更专业的选择。它提供了两个核心函数：

reflect.TypeOf()

reflect.TypeOf 接收一个接口参数，返回该值的 reflect.Type 对象。这允许你获取包含包名在内的完整类型定义，适合需要区分 *int 指针类型和普通 int 的场景。

package main
import (
	"fmt"
	"reflect"
)

func main() {
	var days int = 42
	var typemessage string = "go find type"

	// 返回具体的类型描述，例如 "int" 或 "string"
	fmt.Printf("variable days=%v is of type %v \n", days, reflect.TypeOf(days))
	fmt.Printf("variable typemessage='%v' is of type %v \n", typemessage, reflect.TypeOf(typemessage))
}

reflect.ValueOf().Kind()

相比之下，reflect.ValueOf(v).Kind() 返回的是变量的“种类”（Kind），如 reflect.Int 或 reflect.String。它不区分指针、数组等衍生类型的基础类型属性（例如指针的 Kind 仍然是它所指向的基础类型的 Kind，但可以通过进一步判断是否为 Pointer 来区分）。

package main
import (
	"fmt"
	"reflect"
)

func main() {
	var days int = 42
	var objectValue float32 = 10.2

	// .Kind() 返回 reflect.Kind 枚举值，通常转为字符串显示
	fmt.Printf("variable days=%v is of type %v \n", days, reflect.ValueOf(days).Kind())
	fmt.Printf("variable objectValue=%v is of type %v \n", objectValue, reflect.ValueOf(objectValue).Kind())
}

这种方式适合进行大类判断。缺点是会生成新的 reflect.Value 对象，若在内层高频循环中使用需注意内存开销。

使用类型断言

类型断言（Type Assertion）结合 switch...case 语句，是处理 interface{} 类型最具有 Go 风格的做法。它不仅能够判断类型，还能在判断成功后将值转换为具体类型以供后续使用。

package main
import (
	"fmt"
)

// 自定义函数演示类型分组
func typeofObject(variable interface{}) string {
	switch variable.(type) {
	case int:
		return "int"
	case float32:
		return "float32"
	case bool:
		return "boolean"
	case string:
		return "string"
	default:
		return "unknown"
	}
}

func main() {
	count := 42
	message := "test"
	isCheck := true
	amount := 10.2

	fmt.Println("Using type assertions")
	fmt.Println(typeofObject(count))
	fmt.Println(typeofObject(message))
	fmt.Println(typeofObject(isCheck))
	fmt.Println(typeofObject(amount))
}

优势说明：可以使用 default 分支处理未预期的类型，或者通过 case 分组将 int32、int64 等统一归类为 “int”，减少重复代码。

封装自定义方法

为了复用上述检查逻辑，可以将其封装为独立的辅助函数。这不仅让业务代码更整洁，也能统一项目的类型判断规范。

// 基于 fmt.Sprintf 封装
func getTypeByFmt(v interface{}) string {
	return fmt.Sprintf("%T", v)
}

// 基于 reflect.TypeOf 封装
func getTypeByReflect(v interface{}) string {
	return reflect.TypeOf(v).String()
}

调用这些封装好的函数即可在任何位置快速获取类型字符串，而无需每次引入额外的包或书写冗长的逻辑。

以上就是 Golang 检查变量类型的详细内容，更多关于 Go 语言类型处理的资料请关注本站其它相关文章！