TypeOf 没有实例并将结果传递给 func

各位小伙伴们，大家好呀！看看今天我又给各位带来了什么文章？本文标题是《TypeOf 没有实例并将结果传递给 func》，很明显是关于Golang的文章哈哈哈，其中内容主要会涉及到golang等等，如果能帮到你，觉得很不错的话，欢迎各位多多点评和分享！

问题内容

是否有可能在没有实例的情况下获得“类型”？我见过一些使用的例子，reflect.TypeOf()但它们都处理一个实例。

下面是我正在尝试做的一个片段：

import (
    "net/http"
)

type ParamReader struct {
    // The request from which to extract parameters
    context *http.Request
}

// Initialize the ParamReader with a specific http request. This serves
// as the 'context' of our param reader. All subsequent calls will validate
// the params that are present on this assigned http.Request
func (p *ParamReader) Context(r *http.Request) {
    p.context = r
}

// Validate that a given param 's' is both present and a valid
// value of type 't'. A value is demeed valid if a conversion from 
// its string representation to 't' is possible
func(p *ParamReader) Require(s string, t Type) {
    // if context not have 's'
    //      addError('s' is not present)
    //      return


    if( t == typeof(uint64)) {
        // If not s -> uint64
        //      addError('s' is not a valid uint64)
    } else if (t == typeof(uint32)) {
        // ....
    } / ....
}

我使用的一个例子是

func (h *Handler) OnRequest(r *http.Request) {
  h.ParamReader.Context(r)
  h.ParamReader.Require("age", uint16)
  h.ParamReader.Require("name", string)
  h.ParamReader.Require("coolfactor", uint64)
  h.ParamReader.Optional("email", string, "unspecified")
  h.ParamReader.Optional("money", uint64, "0")

  if h.ParamReader.HasErrors() {
    // Iterate or do something about the errors
  } else {
    coolness := h.ParamReader.ReadUint64("coolfactor")
    email := h.ParamReader.ReadString("email")
    money := h.ParamReader.ReadUint64(0)
  }
}

请注意，在写完之后，我意识到我可以提供一个"RequireUint64","RequireUint32"等。也许这就是 Go 的方式？

正确答案

是的，这是可能的。诀窍是从指向类型的指针开始（其值可以是 typed nil，这完全可以），然后使用Type.Elem()来获取reflect.Type指向类型（ 基 类型）的描述符。

看一些例子：

t := reflect.TypeOf((*int)(nil)).Elem()
fmt.Println(t)

t = reflect.TypeOf((*http.Request)(nil)).Elem()
fmt.Println(t)

t = reflect.TypeOf((*os.File)(nil)).Elem()
fmt.Println(t)

输出（在Go Playground上试试）：

int
http.Request
os.File

查看相关问题：

[Golang反映：从名称中获取类型表示？](https://stackoverflow.com/questions/40879748/golang- reflect-get-type-representation-from-name/40882963#40882963)

[如何获取类型的字符串表示？](https://stackoverflow.com/questions/41905222/how-to-get-the- string-representation-of-a-type/41905585#41905585)

如果你想传递类型并在switches中使用它们，你可以像这样创建它们并将它们存储在全局变量中，并引用全局变量：

var (
    intType         = reflect.TypeOf((*int)(nil))
    httpRequestType = reflect.TypeOf((*http.Request)(nil))
    osFileType      = reflect.TypeOf((*os.File)(nil))
    int64Type       = reflect.TypeOf((*uint64)(nil))
)

func printType(t reflect.Type) {
    switch t {
    case intType:
        fmt.Println("Type: int")
    case httpRequestType:
        fmt.Println("Type: http.request")
    case osFileType:
        fmt.Println("Type: os.file")
    case int64Type:
        fmt.Println("Type: uint64")
    default:
        fmt.Println("Type: Other")
    }
}

func main() {
    printType(intType)
    printType(httpRequestType)
    printType(osFileType)
    printType(int64Type)
}

上面的输出（在Go Playground上试试）：

Type: int
Type: http.request
Type: os.file
Type: uint64

但老实说，如果您以这种方式使用它并且不使用reflect.Type's 方法，那么创建常量会更容易和更有效。它可能看起来像这样：

type TypeDesc int

const (
    typeInt TypeDesc = iota
    typeHttpRequest
    typeOsFile
    typeInt64
)

func printType(t TypeDesc) {
    switch t {
    case typeInt:
        fmt.Println("Type: int")
    case typeHttpRequest:
        fmt.Println("Type: http.request")
    case typeOsFile:
        fmt.Println("Type: os.file")
    case typeInt64:
        fmt.Println("Type: uint64")
    default:
        fmt.Println("Type: Other")
    }
}

func main() {
    printType(typeInt)
    printType(typeHttpRequest)
    printType(typeOsFile)
    printType(typeInt64)
}

输出是一样的。在Go Playground上尝试一下。

今天关于《TypeOf 没有实例并将结果传递给 func》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！