Go 语言，使用变量之前需要先进行变量的声明。

var s string = “Golang"n := 666

Go 语言有两类变量

包级别(package varible)：在 package 级别可见的变量。如果是导出变量，该变量也可以被视为全局变量；

局部变量(local varible)：函数或方法体内声明的变量，仅在函数或方法体内可见。

1. 包级别变量

包级变量使用var 关键字的变量声明形式，从变量声明的时候是否延迟初始化这个角度对包级变量进行一次分类。

1). 声明并同时显式初始化

//$GOROOT/src/io/pipe.govar ErrClosedPipe = errors.New("io: read/write on closed pipe")//$GOROOT/src/io/io.govar EOF = errors.New("EOF”)

上面，对于变量声明的同时进行显式初始化的这类包级变量，格式:

var 变量名 = 初始化表达式

编译器会自动根据等号右侧 初始化表达式 结果值的类型确定左侧声明的变量的类型。

var num = 16var pi = 3.14

Go 会为包级变量设置默认类型,对于未显式赋予类型的整型变量 num，编译器会设置默认类型 int；而浮点型变量 pi 的默认类型则为 float64。如果不想使用默认类型，而是要显式为 num 和 pi 指定类型。

var num = int32(16)var pi  = float64(3.14)

上面是默认类型和显式指定类型两种声明形式，尤其是在将这些变量放在一个 var 块中声明时

var (  num = 17  pi = float32(3.14))

2). 延迟初始化

有时候，声明并不立即显式初始化的包级变量，虽然没有显式初始化，Go 语言也会让这些变量拥有初始的“零值”。如果是自定义的类型，保证其零值可用是非常必要的，形式如下：

var a int32var f float64

3). 声明聚类与就近原则

Go 语言提供 var 块用于将多于一个的变量声明放在一起，我们习惯：

1 将同一类的变量声明放在一个 var 块中，不同类的声明放在不同的 var 块中；

2 将延迟初始化的变量声明放在一个 var 块，而将声明且显式初始化的变量放在另一个 var 块中。

Go 标准库中的代码：

// $GOROOT/src/net/http/server.govar (    bufioReaderPool   sync.Pool    bufioWriter2kPool sync.Pool    bufioWriter4kPool sync.Pool)var copyBufPool = sync.Pool{    New: func() interface{} {        b := make([]byte, 32*1024)        return &b    },}

copyBufPool 变量没有放入 var 块就是因为它的声明是带有显式初始化的，而 var 块中的变量声明都是延迟初始化的

// $GOROOT/src/net/net.govar (    aLongTimeAgo = time.Unix(1, 0)    noDeadline = time.Time{}    noCancel   = (chan struct{})(nil))var threadLimit chan struct{}

threadLimit 单独放在 var 块外面，它是延迟初始化的变量声明，它与以上的 var 块中时间限制的变量也有所不同。

变量声明最佳实践中还有一个原则-就近原则，如果一个包级变量在包内部多处使用，放在源文件头部声明比较恰当直观。

/ $GOROOT/src/net/http/request.govar ErrNoCookie = errors.New("http: named cookie not present")func (r *Request) Cookie(name string) (*Cookie, error) {    for _, c := range readCookies(r.Header, name) {        return c, nil    }    return nil, ErrNoCookie}

2. 局部变量的声明形式

比上面的包级别变量，局部变量多了短变量声明形式，局部变量采用最多的一种声明形式。

对于延迟初始化的局部变量声明，用带有 var 的声明形式。

// $GOROOT/src/strings/replace.gofunc (r *byteReplacer) Replace(s string) string {  var buf []byte // 延迟初始化  for i := 0; i < len(s); i++ {    b := s[i]    if r[b] != b {      if buf == nil {        buf = []byte(s)      }      buf[i] = r[b]    }  }  if buf == nil {    return s  }  return string(buf)}

    var err error  这也是我们日常常见的声明方式

短变量声明形式是局部变量最常用的声明形式，在 Go 标准库代码中广泛使用。

num := 17             //默认类型pi := float32(3.14)   //显示转型

// $GOROOT/src/net/net.gofunc (v *Buffers) WriteTo(w io.Writer) (n int64, err error) {    if wv, ok := w.(buffersWriter); ok {        return wv.writeBuffers(v)    }    for _, b := range *v {        nb, err := w.Write(b)        n += int64(nb)        if err != nil {            v.consume(n)            return n, err        }    }    v.consume(n)    return n, nil}

我们看到Go源代码net中，if wv, ok := w.(buffersWriter); ok和for _, b := range *v都使用了短变量声明形式，这也体现出“就近”原则，让变量的作用域最小化。

设计良好的函数/方法的原则是“单一职责”，因此每个函数/方法规模都不大，很少需要应用 var 块来声明局部变量，如果你在声明局部变量时遇到这种场景，那就使用 var 块来声明多于一个的局部变量吧。看一下Go标准库中的源代码是这么使用的:

// $GOROOT/src/net/dial.gofunc (r *Resolver) resolveAddrList(ctx context.Context, op, network,addr string, hint Addr) (addrList, error) {    ... ...    var (        tcp      *TCPAddr        udp      *UDPAddr        ip       *IPAddr        wildcard bool    )   ... ...}