Golang 中的全局变量

Question

我一直在阅读一本关于 Golang 的书，通常使用全局变量来公开私有函数的结果。为什么不公开公共功能？这是一个例子。 我来自java，这对我来说很棘手。使用这样的全局变量有什么好处？

编辑：我注意到没有括号我没有调用该函数。这只是一个指针。这是一个好的做法还是有一些优势？

package config

import "time"

var (
    
    GetHTTPServerAddress = getHTTPServerAddress
    GetHTTPReadTimeout = getHTTPReadTimeout
    GetHTTPWriteTimeout = getHTTPWriteTimeout
)

func getHTTPServerAddress() string {
    return getConfigString("http.server_address")
}

func getHTTPReadTimeout() time.Duration {
    return getConfigDuration("http.read_timeout")
}

func getHTTPWriteTimeout() time.Duration {
    return getConfigDuration("http.write_timeout")
}

Answer 1

我一直在读一本关于 Golang 的书，通常使用全局变量来公开私有函数的结果。

公开私有函数的结果，而不是函数本身；你的例子有点不对劲。如果没有括号，您将暴露函数本身。

package main

import (
    "fmt"
)

var(
    FooItself = foo      // (func() string)(0x108b720)
    FooResult = foo()    // "bar"
)

func main() {
    fmt.Printf("%#v\n", FooItself)
    fmt.Printf("%#v\n", FooResult)
}

func foo() string {
    return "bar"
}

Try it.

你的例子看起来更像这样。

package config

var (
    // You wouldn't call the variable "Get*", that exposes
    // the implementation.
    HTTPServerAddress = getHTTPServerAddress()
    HTTPReadTimeout = getHTTPReadTimeout()
    HTTPWriteTimeout = getHTTPWriteTimeout()
)

func getHTTPServerAddress() string {
    return getConfigString("http.server_address")
}

func getHTTPReadTimeout() time.Duration {
    return getConfigDuration("http.read_timeout")
}

func getHTTPWriteTimeout() time.Duration {
    return getConfigDuration("http.write_timeout")
}

但不需要私有方法。只需运行该函数并将其分配给全局。

package config

var (
    HTTPServerAddress = getConfigString("http.server_address")
    HTTPReadTimeout = getConfigDuration("http.read_timeout")
    HTTPWriteTimeout = getConfigDuration("http.write_timeout")
)

现在人们可以使用config.HTTPServerAddress 并且细节保持隐藏，不需要额外的一层方法。

---

是的，它可以在结果公共函数上完成。一个非常常见的例子是错误代码。例如，在net/http。

var (
    ErrBodyNotAllowed = errors.New("http: request method or response status code does not allow body")
    ErrHijacked = errors.New("http: connection has been hijacked")
)

在 Java 中，您可以为每种类型的错误创建一个异常子类。在 Go 中，您创建一个对象，将其作为全局变量共享，并且所有内容都引用该对象。

目的是向用户隐藏详细信息。错误的确切措辞可以更改，但只要每个人都引用net.http.ErrBodyNotAllowed，他们的代码仍然可以工作。

---

io/fs 有一个更复杂的示例，公开其私有方法的结果。

var (
    ErrInvalid    = errInvalid()    // "invalid argument"
    ErrPermission = errPermission() // "permission denied"
    ErrExist      = errExist()      // "file already exists"
    ErrNotExist   = errNotExist()   // "file does not exist"
    ErrClosed     = errClosed()     // "file already closed"
)

func errInvalid() error    { return oserror.ErrInvalid }
func errPermission() error { return oserror.ErrPermission }
func errExist() error      { return oserror.ErrExist }
func errNotExist() error   { return oserror.ErrNotExist }
func errClosed() error     { return oserror.ErrClosed }

为什么在这里使用私有方法包装器？为什么不ErrInvalid = oserror.ErrInvalid？

（我假设）Go 想要隐藏 oserror，even from the documentation！

oserror 只是制作错误对象来定义其可能的错误。

package oserror

import "errors"

var (
    ErrInvalid    = errors.New("invalid argument")
    ErrPermission = errors.New("permission denied")
    ErrExist      = errors.New("file already exists")
    ErrNotExist   = errors.New("file does not exist")
    ErrClosed     = errors.New("file already closed")
)

Answer 2

如果是函数的结果，可能类似于static 成员初始化，甚至可能是static final。

您链接的示例表明它是某种配置加载过程，并且值公开以供全局​​使用。

预计算数据也并非闻所未闻。

但是，如果您看到函数指针，则可以启用模拟。

YMMV。有时它也只是一种反模式。