如何在運行時檢查變量類型在Go語言

Question

我必須聲明如下

CURLcode curl_wrapper_easy_setopt_long(CURL* curl, CURLoption option, long param); 
CURLcode curl_wrapper_easy_setopt_str(CURL* curl, CURLoption option, char* param); 

幾個C函數，我想揭露那些像這樣

func (e *Easy)SetOption(option Option, param interface{}) 

，所以我需要一個去功能能夠在運行時檢查參數類型。我該怎麼做，這是一個好主意（如果不是這種情況下的良好做法）？

Answer 1

見類型斷言這裏：

http://golang.org/ref/spec#Type_assertions

我主張一個明智的類型（字符串，UINT64）只有等，並將其作爲鬆散越好，執行轉換到最後的原生型。

Answer 2

這有什麼錯

func (e *Easy)SetStringOption(option Option, param string) 
func (e *Easy)SetLongOption(option Option, param long) 

等等？

Answer 3

看來，圍棋有開關的特殊形式奉獻給這個（它被稱爲型開關）：

func (e *Easy)SetOption(option Option, param interface{}) { 

    switch v := param.(type) { 
    default: 
     fmt.Printf("unexpected type %T", v) 
    case uint64: 
     e.code = Code(C.curl_wrapper_easy_setopt_long(e.curl, C.CURLoption(option), C.long(v))) 
    case string: 
     e.code = Code(C.curl_wrapper_easy_setopt_str(e.curl, C.CURLoption(option), C.CString(v))) 
    } 
} 

Answer 4

通過@Darius答案是最地道的（也可能是更好的性能）的方法。一個限制是你正在檢查的類型必須是interface{}。如果您使用混凝土類型，則會失敗。

另一種在運行時確定某些東西的方法，包括具體類型，就是使用Go reflect包。鏈接TypeOf(x).Kind()在一起，你可以得到一個reflect.Kind值，它是一個uint類型：http://golang.org/pkg/reflect/#Kind

然後，您可以做類型檢查開關塊之外，像這樣：

import (
    "fmt" 
    "reflect" 
) 

// .... 

x := 42 
y := float32(43.3) 
z := "hello" 

xt := reflect.TypeOf(x).Kind() 
yt := reflect.TypeOf(y).Kind() 
zt := reflect.TypeOf(z).Kind() 

fmt.Printf("%T: %s\n", xt, xt) 
fmt.Printf("%T: %s\n", yt, yt) 
fmt.Printf("%T: %s\n", zt, zt) 

if xt == reflect.Int { 
    println(">> x is int") 
} 
if yt == reflect.Float32 { 
    println(">> y is float32") 
} 
if zt == reflect.String { 
    println(">> z is string") 
} 

它打印出局：

reflect.Kind: int 
reflect.Kind: float32 
reflect.Kind: string 
>> x is int 
>> y is float32 
>> z is string 

再一次，這可能不是首選的方法，但很好了解其他選項。

Answer 5

quux00的答案只講述了比較基本類型。

如果您需要比較您定義的類型，則不應使用reflect.TypeOf(xxx)。相反，請使用reflect.TypeOf(xxx).Kind()。

有兩類類型：

• 直接類型（你直接定義的類型）
• 基本類型（int，float64，結構，...）

這是一個完整的例子：

type MyFloat float64 
type Vertex struct { 
    X, Y float64 
} 

type EmptyInterface interface {} 

type Abser interface { 
    Abs() float64 
} 

func (v Vertex) Abs() float64 { 
    return math.Sqrt(v.X*v.X + v.Y*v.Y) 
} 

func (f MyFloat) Abs() float64 { 
    return math.Abs(float64(f)) 
} 

var ia, ib Abser 
ia = Vertex{1, 2} 
ib = MyFloat(1) 
fmt.Println(reflect.TypeOf(ia)) 
fmt.Println(reflect.TypeOf(ia).Kind()) 
fmt.Println(reflect.TypeOf(ib)) 
fmt.Println(reflect.TypeOf(ib).Kind()) 

if reflect.TypeOf(ia) != reflect.TypeOf(ib) { 
    fmt.Println("Not equal typeOf") 
} 
if reflect.TypeOf(ia).Kind() != reflect.TypeOf(ib).Kind() { 
    fmt.Println("Not equal kind") 
} 

ib = Vertex{3, 4} 
if reflect.TypeOf(ia) == reflect.TypeOf(ib) { 
    fmt.Println("Equal typeOf") 
} 
if reflect.TypeOf(ia).Kind() == reflect.TypeOf(ib).Kind() { 
    fmt.Println("Equal kind") 
} 

輸出將是：

main.Vertex 
struct 
main.MyFloat 
float64 
Not equal typeOf 
Not equal kind 
Equal typeOf 
Equal kind 

正如你所看到的，reflect.TypeOf(xxx)返回直接類型，你可能想使用，而reflect.TypeOf(xxx).Kind()返回基本類型。

---

下面是結論。如果您需要與基本類型進行比較，請使用reflect.TypeOf(xxx).Kind();如果您需要與自定義類型進行比較，請使用reflect.TypeOf(xxx)。

if reflect.TypeOf(ia) == reflect.TypeOf(Vertex{}) { 
    fmt.Println("self-defined") 
} else if reflect.TypeOf(ia).Kind() == reflect.Float64 { 
    fmt.Println("basic types") 
}