如何在围棋中找到对象的类型?

我如何在围棋中找到对象的类型?在Python中，我只使用typeof来获取对象的类型。在围棋中也有类似的情况，有没有办法实现同样的情况?

下面是我正在迭代的容器:

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

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

543031 次浏览
小开

使用反映包:

包反射实现运行时反射，允许程序 操作任意类型的对象。典型的用法是取a 值与静态类型接口{}并提取其动态类型 信息调用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

游乐场 .

小开
最佳答案

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


}

输出:

string
int
float64

参见:http://play.golang.org/p/XQMcUVsOja查看它的操作。

更多文档:http://golang.org/pkg/reflect/#Type

小开

要获得字符串表示形式:

从# EYZ0

%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
小开
最好的方法是在谷歌中使用反射的概念 reflect.TypeOf给出类型和包名
reflect.TypeOf().Kind()给出下划线类型

小开

我找到了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类型为"

小开

我就会远离反思。包中。而是使用%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)
}
小开

你可以使用reflect.TypeOf。

  • 基本类型(如。: int， string):它将返回它的名称(例如:int， string)
  • struct:它将返回格式为<package name>.<struct name>的内容(例如:main.test)
小开

获取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

小开

你可以在运行时使用"reflect" packages 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)
}
小开

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

小开

反映包来拯救:

reflect.TypeOf(obj).String()

检查演示

小开

如果我们有这些变量:

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: 反映。TypeOf功能:要使用此功能，您应该进口“反映”

fmt.Println(reflect.TypeOf(enabled)) // enabled type:  bool

3: reflect.ValueOf (X) .Kind ():要使用这个功能，你应该进口“反映”

fmt.Println(reflect.ValueOf(counter).Kind()) // counter type:  int
小开

您可以使用: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)
}
}
}
小开

对于数组和切片使用Type.Elem():

a := []string{"foo", "bar", "baz"}
fmt.Println(reflect.TypeOf(a).Elem())
小开

我整理了以下内容。

  1. fmt % T:值类型的go语法表示
  2. reflect.TypeOf。# EYZ0
  3. reflect.TypeOf。# EYZ0
  4. 类型断言

例子

package _test


import (
"fmt"
"reflect"
"testing"
)


func TestType(t *testing.T) {
type Person struct {
name string
}
var i interface{}
i = &Person{"Carson"}


for idx, d := range []struct {
actual   interface{}
expected interface{}
}{
{fmt.Sprintf("%T", "Hello") == "string", true},
{reflect.TypeOf("string").String() == "string", true},
{reflect.TypeOf("string").Kind() == reflect.String, true},
{reflect.TypeOf(10).String() == "int", true},
{reflect.TypeOf(10).Kind() == reflect.Int, true},
{fmt.Sprintf("%T", 1.2) == "float64", true},
{reflect.TypeOf(1.2).String() == "float64", true},
{reflect.TypeOf(1.2).Kind() == reflect.Float64, true},
{reflect.TypeOf([]byte{3}).String() == "[]uint8", true},
{reflect.TypeOf([]byte{3}).Kind() == reflect.Slice, true},
{reflect.TypeOf([]int8{3}).String() == "[]int8", true},
{reflect.TypeOf([]int8{3}).Kind() == reflect.Slice, true},
{reflect.TypeOf(Person{"carson"}).Kind() == reflect.Struct, true},
{reflect.TypeOf(&Person{"carson"}).Kind() == reflect.Ptr, true},
{fmt.Sprintf("%v", i.(*Person)) == "&{Carson}", true},
{fmt.Sprintf("%+v", i.(*Person)) == "&{name:Carson}", true},
} {
if d.actual != d.expected {
t.Fatalf("%d | %s", idx, d.actual)
}
}
}

go playground

小开

如果你想检测if表达式中的类型:

if str, ok := myvar.(string); ok {
print("It's a string")
}

或者没有类型断言(可能会产生错误):

if reflect.TypeOf(myvar).String() == "string" {
print("It's a string")
}

提交答案