Question

如何在Go中找到对象的类型？在Python中，我只使用typeof来获取对象的类型。同样在Go中，有没有办法实现相同的？

这是我正在迭代的容器：

for e := dlist.Front(); e != nil; e = e.Next() {
    lines := e.Value
    fmt.Printf(reflect.TypeOf(lines))
}

在这种情况下，我无法获得对象行的类型，这是一个字符串数组。

Answer 1

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))

}

请参阅：http://play.golang.org/p/XQMcUVsOja以查看其实际效果。

此处有更多文档：http://golang.org/pkg/reflect/#Type

Answer 2

我找到了三种在运行时返回变量类型的方法：

使用string formatting

func typeof(v interface{}) string {
    return fmt.Sprintf("%T", v)
}

使用reflect package

func typeof(v interface{}) string {
    return reflect.TypeOf(v).String()
}

使用type assertions

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”

Answer 3

使用reflect包：

包反映实现运行时反射，允许程序操纵任意类型的对象。典型的用途是采取使用静态类型接口{}的值并提取其动态类型通过调用TypeOf来返回类型的信息。

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

Playground

使用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

Playground

Answer 4

获取字符串表示：

来自http://golang.org/pkg/fmt/

％T是值类型
的Go语法表示

package main
import "fmt"
func main(){
    types := []interface{} {"a",6,6.0,true}
    for _,v := range types{
        fmt.Printf("%T\n",v)
    }
}

输出：

string
int
float64
bool

Answer 5

我会远离反思。包。而是使用％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)
 }

Answer 6

最好的方法是在Google中使用反射概念 reflect.TypeOf给出类型以及包名称
reflect.TypeOf().Kind()给出了下划线类型

Answer 7

简而言之，请使用fmt包中的fmt.Printf("%T", var1)或其他变体。

Answer 8

您可以使用＆＃34;反射＆＃34;在运行时检查任何变量/实例的类型。包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)
}

Answer 9

获取struct
中的字段类型

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

Answer 10

您可以使用reflect.TypeOf。

基本类型（例如：int，string）：它将返回其名称（例如：int，string）
struct：它将返回<package name>.<struct name>格式的内容（例如：main.test）

Answer 11

reflect包来救援：

reflect.TypeOf(obj).String()

选中此demo

Answer 12

您可以使用fmt软件包fmt.Printf（）方法，更多信息：https://golang.org/pkg/fmt/

例如： https://play.golang.org/p/aJG5MOxjBJD

Answer 13

如果我们有以下变量：

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

Answer 14

您可以像以下playground一样使用：data() { let list = [ { name: "animal", pos: 0 }, { name: "aloe", pos: 1 }, { name: "arm", pos: 2 }, { name: "arsenal", pos: 3 }, { name: "antenna", pos: 4 }, { name: "antler", pos: 5 }, { name: "armband", pos: 6 }, ] return { original_list: JSON.parse(JSON.stringify(list)), list: list, }; }, methods: { listToJSON(list) { return JSON.stringify(list, null, 2) }, updateList(context) { let old = context.oldIndex let $new = context.newIndex let temp_name = this.original_list[old].name this.original_list[old].name = this.original_list[$new].name this.original_list[$new].name = temp_name } },

interface{}..(type)

如何在Go中找到一个对象的类型？

14 个答案: