如何在 Go 中找到对象的类型？在 Python 中，我只是typeof用来获取对象的类型。同样在 Go 中，有没有办法实现相同的？
这是我从中迭代的容器：
for e := dlist.Front(); e != nil; e = e.Next() {
lines := e.Value
fmt.Printf(reflect.TypeOf(lines))
}
在这种情况下，我无法获取对象行的类型，即字符串数组。
问问题
483305 次
16 回答
598
Go 反射包具有检查变量类型的方法。
以下代码段将打印出字符串、整数和浮点数的反射类型。
package main
import (
"fmt"
"reflect"
)
func main() {
tst := "string"
tst2 := 10
tst3 := 1.2
fmt.Println(reflect.TypeOf(tst))
fmt.Println(reflect.TypeOf(tst2))
fmt.Println(reflect.TypeOf(tst3))
}
输出：
Hello, playground
string
int
float64
请参阅：http ://play.golang.org/p/XQMcUVsOja以查看它的实际效果。
更多文档：http: //golang.org/pkg/reflect/#Type
于 2013-11-24T02:58:12.777 回答
532
我找到了 3 种在运行时返回变量类型的方法：
使用字符串格式化
func typeof(v interface{}) string {
return fmt.Sprintf("%T", v)
}
使用反射包
func typeof(v interface{}) string {
return reflect.TypeOf(v).String()
}
使用类型断言
func typeof(v interface{}) string {
switch v.(type) {
case int:
return "int"
case float64:
return "float64"
//... etc
default:
return "unknown"
}
}
每种方法都有不同的最佳用例：
字符串格式 - 短小占用空间（不需要导入反射包）
反射包 - 当需要有关类型的更多详细信息时，我们可以访问完整的反射功能
类型断言 - 允许对类型进行分组，例如将所有 int32、int64、uint32、uint64 类型识别为“int”
于 2014-11-26T23:39:08.017 回答
55
使用反射包：
包反射实现运行时反射，允许程序操作任意类型的对象。典型的用法是取一个静态类型 interface{} 的值，通过调用 TypeOf 提取其动态类型信息，返回一个 Type。
package main
import (
"fmt"
"reflect"
)
func main() {
b := true
s := ""
n := 1
f := 1.0
a := []string{"foo", "bar", "baz"}
fmt.Println(reflect.TypeOf(b))
fmt.Println(reflect.TypeOf(s))
fmt.Println(reflect.TypeOf(n))
fmt.Println(reflect.TypeOf(f))
fmt.Println(reflect.TypeOf(a))
}
产生：
bool
string
int
float64
[]string
使用示例ValueOf(i interface{}).Kind()：
package main
import (
"fmt"
"reflect"
)
func main() {
b := true
s := ""
n := 1
f := 1.0
a := []string{"foo", "bar", "baz"}
fmt.Println(reflect.ValueOf(b).Kind())
fmt.Println(reflect.ValueOf(s).Kind())
fmt.Println(reflect.ValueOf(n).Kind())
fmt.Println(reflect.ValueOf(f).Kind())
fmt.Println(reflect.ValueOf(a).Index(0).Kind()) // For slices and strings
}
产生：
bool
string
int
float64
string
于 2013-11-24T02:56:35.883 回答
45
To get a string representation:
From http://golang.org/pkg/fmt/
%T a Go-syntax representation of the type of the value
package main
import "fmt"
func main(){
types := []interface{} {"a",6,6.0,true}
for _,v := range types{
fmt.Printf("%T\n",v)
}
}
Outputs:
string
int
float64
bool
于 2014-02-07T21:41:09.543 回答
17
我会远离反射。包裹。而是使用 %T
package main
import (
"fmt"
)
func main() {
b := true
s := ""
n := 1
f := 1.0
a := []string{"foo", "bar", "baz"}
fmt.Printf("%T\n", b)
fmt.Printf("%T\n", s)
fmt.Printf("%T\n", n)
fmt.Printf("%T\n", f)
fmt.Printf("%T\n", a)
}
于 2017-05-01T19:34:14.313 回答
15
最好的方法是在 Google 中使用反射概念。
reflect.TypeOf给出类型以及包名
reflect.TypeOf().Kind()给出下划线类型
于 2014-08-22T08:59:50.057 回答
10
简而言之，请使用fmt.Printf("%T", var1) fmt 包中的或其其他变体。
于 2018-05-08T16:25:15.697 回答
5
获取结构中的字段类型
package main
import (
"fmt"
"reflect"
)
type testObject struct {
Name string
Age int
Height float64
}
func main() {
tstObj := testObject{Name: "yog prakash", Age: 24, Height: 5.6}
val := reflect.ValueOf(&tstObj).Elem()
typeOfTstObj := val.Type()
for i := 0; i < val.NumField(); i++ {
fieldType := val.Field(i)
fmt.Printf("object field %d key=%s value=%v type=%s \n",
i, typeOfTstObj.Field(i).Name, fieldType.Interface(),
fieldType.Type())
}
}
输出
object field 0 key=Name value=yog prakash type=string
object field 1 key=Age value=24 type=int
object field 2 key=Height value=5.6 type=float64
在 IDE 中查看https://play.golang.org/p/bwIpYnBQiE
于 2017-12-06T10:06:16.280 回答
5
您可以使用“反射”包TypeOf函数或使用以下方法在运行时检查任何变量/实例的类型fmt.Printf()：
package main
import (
"fmt"
"reflect"
)
func main() {
value1 := "Have a Good Day"
value2 := 50
value3 := 50.78
fmt.Println(reflect.TypeOf(value1 ))
fmt.Println(reflect.TypeOf(value2))
fmt.Println(reflect.TypeOf(value3))
fmt.Printf("%T",value1)
fmt.Printf("%T",value2)
fmt.Printf("%T",value3)
}
于 2018-01-23T02:43:00.173 回答
5
如果我们有这个变量：
var counter int = 5
var message string = "Hello"
var factor float32 = 4.2
var enabled bool = false
1：fmt.Printf %T格式：要使用此功能，您应该导入“fmt”
fmt.Printf("%T \n",factor ) // factor type: float32
2：reflect.TypeOf功能：要使用此功能，您应该导入“reflect”
fmt.Println(reflect.TypeOf(enabled)) // enabled type: bool
3：reflect.ValueOf(X).Kind()：要使用此功能，您应该导入“reflect”
fmt.Println(reflect.ValueOf(counter).Kind()) // counter type: int
于 2019-12-26T15:06:12.770 回答
2
你可以使用：interface{}..(type)就像在这个操场上一样
package main
import "fmt"
func main(){
types := []interface{} {"a",6,6.0,true}
for _,v := range types{
fmt.Printf("%T\n",v)
switch v.(type) {
case int:
fmt.Printf("Twice %v is %v\n", v, v.(int) * 2)
case string:
fmt.Printf("%q is %v bytes long\n", v, len(v.(string)))
default:
fmt.Printf("I don't know about type %T!\n", v)
}
}
}
于 2020-06-01T07:30:31.303 回答
1
对于数组和切片使用Type.Elem()：
a := []string{"foo", "bar", "baz"}
fmt.Println(reflect.TypeOf(a).Elem())
于 2021-08-19T09:48:10.140 回答
0
你可以看到这个演示。它演示了如何显示 const 变量的类型。 https://go.dev/play/p/o89rrRj9mPM
于 2022-01-27T03:11:36.967 回答
0
你可以使用reflect.TypeOf.
- 基本类型（例如：
int，string）：它将返回其名称（例如：int，string） - struct：它会以某种格式返回一些东西
<package name>.<struct name>（例如main.test：）
于 2017-10-11T06:07:39.187 回答
-2
您可以只使用 fmt 包 fmt.Printf() 方法，更多信息：https ://golang.org/pkg/fmt/
示例： https: //play.golang.org/p/aJG5MOxjBJD
于 2018-06-07T20:39:55.427 回答