戈朗 : implicit vs explicit func definition

Question

考虑这个包:

package A
var X="change me"
var Y=func(i int) int { return i*i) }
func Z(i int) int { return -i) }

可以在另一个包中更改两个显式变量 (X,Y)，例如 main...

package main
import "A"
func main () {
    A.X="done"
    A.Y=func (i int) int { return i*i*i }
    print(A.X,A.Y(7))
    //... but A.Z apparently can't be changed.
    //A.Z=func (int i) int { return i*i*i } //main.go:8: cannot assign to A.Z
}

显然，定义函数变量(如 Y)和显式函数(如 Z)之间存在差异。我用谷歌搜索了这个但没有发现太多启蒙方式。看起来好像 var SomeFunc=func (...) 确实定义了一个变量，但 func SomeFunc(...) 定义了一个常量。

PS:我在研究这个时发现的一个小好东西，到目前为止我读过的 Go 书籍中没有提到过。包导入之前的一个点导入名称而无需限定它们:

package main
import . "A"
func main () {
    X="done"
    Y=func (i int) int { return i*i*i }
    print(X,Y(7))
}

Answer 1

func SomeFunc()，实质上创建了标识符 SomeFunc 到您定义的函数的强/常量/不可变绑定(bind)。当你像这样创建一个变量时:

var (
    SomeFunc = func(i int) int {
        return i * 2
    }
)

您创建了一个func(int) int 类型的全局变量。您可以稍后重新分配此变量。这是您无法使用 func SomeFunc 标识符真正做到的事情。简单地说，这是因为 func SomeFunc() 将函数直接 绑定(bind)到标识符。 var SomeFunc 方法创建一个变量(在本例中类型为 func(int) int)，并且该变量使用您分配的函数进行初始化。与变量的情况一样:可以重新分配。

Example

您可以对函数做的，是使用作用域变量隐藏它们。这可能会被大多数 linter 标记，但这是一种有时在测试中很有用的技术/技巧

Example

至于点导入:除非有非常非常非常的充分理由，否则请不要这样做。一个很好的理由是您编写了一个包添加 到现有的包，因此您不再导入现有的包，而是导入您自己的包。将其视为扩展 一个包。 99% 的时间。无论您做什么，都不要在导入 encoding/json 以将 json 序列化注释添加到结构时使用它来消除错误。在这些情况下，使用下划线:

package foo
import (
    "encoding/json"
)

type Bar struct {
    Foobar string `json:"foobar"`
}

func New() *Bar {
    &Bar{"Default foobar"}
}

不知道 golang 1.8，但这样的包可能会导致编译器错误(包编码/json 已导入但未使用)。要消除该错误，您只需将导入更改为:

import(
    _ "encoding/json"
)

点包、下划线和包别名都遵循相同的规则:尽可能少地使用它们。

---

示例中使用的代码:

package main

import (
    "fmt"
)

var (
    SomeFunc = func(i int) int {
        return i * 2
    }
)

func main() {
    fmt.Println(SomeFunc(2)) // output 4
    reassign()
    fmt.Println(SomeFunc(2)) // output 8
    shadowReassign()
    fmt.Println(SomeFunc(2)) // output 2
}

// global function
func reassign() {
    // assign new function to the global var. Function types MUST match
    SomeFunc = func(i int) int {
        return i * 4
    }
}

// assign function to local reassign variable
func shadowReassign() {
    reassign := func() {
        // same as global reassign
        SomeFunc = func(i int) int {
            return i
        }
    }
    reassign()
}