doujiao3072
2014-02-21 10:40 阅读 93
已采纳

GoLang类型开关中变量“ t”的实际类型是什么?

Given:

type MyInterface interface{

    MyMethod() int

}

var im MyInterface
...

If I call:

switch t := im.(type) {

   case:....

   default:...

}

What is the actual type of the variable t when it is declared? To illustrate the question: If I wanted to write

var t //What type should I use?! 

How would I declare t ?

For example In Delphi we have this structure:

TTypeInfo = record
  Kind: TTypeKind;
  Name: string;
  {TypeData: TTypeData}
end;

I believe I am looking for something in GoLang that is akin to TTypeKind, which has potential values such as tkInteger, tkString etc.

In C++, we find the type_info class type, which also provides some of this functionality.

What type would I use for t in the var t... declaration? Is this even possible?

  • 点赞
  • 写回答
  • 关注问题
  • 收藏
  • 复制链接分享

3条回答 默认 最新

  • 已采纳
    dongshuogai2343 dongshuogai2343 2014-02-21 19:34

    The type switch in Go is weird and special business. It’s not a generalization of another form that happens to be applied to types.

    To my knowledge, you can’t write it using var (and I do recognize that you only mention the var form as illustration).

    Within a case clause of the switch, t has the type specified in that case (see @Mue’s answer). Inside the default clause, it has im’s original type.

    To answer your question, the t symbol in this case is weird and special, and only meaningful in the context of the switch. Its type is context-dependent. I hesitate to even call it a variable.

    Edit, speculation:

    I haven’t looked at the compiler but I suspect it deconstructs each case into a type assertion (cast), the result of which is a local variable within the scope of the case clause. As a syntactic convenience, you can refer to each using the t symbol.

    点赞 评论 复制链接分享
  • dthyxna3894 dthyxna3894 2014-02-21 11:11

    In the following line:

    switch t := im.(type) {
    

    t is already declared & initialized with the value of the type, therefore you don't have to declare it again using var t.

    点赞 评论 复制链接分享
  • dozc1071 dozc1071 2014-02-21 12:13

    It is simple and needs no declaring.

    switch t := anyVar.(type) {
    case ThisType:
        // t is of type ThisType
    case ThatType:
        // t is of type ThatType
    default:
        // t has its original type.
    }
    

    And by the way, please no prefix I for an interface, that's no Go style. Typically you choose a subject matching to the verb(s) of the method(s). See

    type Writer interface {
        Write([]byte) (int, error)
    }
    
    点赞 评论 复制链接分享

相关推荐