go语言的变量声明

1 一般语法

var 变量名 变量类型

多个同类型变量可以声明成一条语句：

var 变量名1, 变量名2, 变量名3 变量类型

变量声明可以是包级的或者函数级的，如：

package main

import "fmt"

var c, python, java bool // 包级变量声明

func main() {
	var i int // 函数级变量声明
	fmt.Println(i, c, python, java)
}

2 添加初始化器

可以给每个变量添加一个初始化器（initializer）：

var 变量名1, 变量名2 变量类型 = 初始化器1, 初始化器2

注意初始化器的个数必须与变量个数相同。
有初始化器时，变量类型可以省略，该变量的类型会根据初始化器自动推断。
例子：

package main

import "fmt"

var i, j int = 1, 2

func main() {
	var c, python, java = true, false, "no!" // 有初始化器时，变量类型可以省略
	fmt.Println(i, j, c, python, java)
}

3 简化变量声明

在函数内，当采用隐式类型声明时（有初始化器，省略变量类型），采用采用更简化的语句：

变量名 := 初始化器

例子：

package main

import "fmt"

func main() {
	var i, j int = 1, 2
	k := 3
	c, python, java := true, false, "no!"

	fmt.Println(i, j, k, c, python, java)
}

注意：在函数外，每个语句都必须以关键字（var, func等）开始，所以不能使用 := 的结构。

4 成块地声明变量

变量可以声明成一个块中，使得结构更加明了：

package main

import (
	"fmt"
	"math/cmplx"
)

var (
	ToBe   bool       = false
	MaxInt uint64     = 1<<64 - 1
	z      complex128 = cmplx.Sqrt(-5 + 12i)
)

func main() {
	fmt.Printf("Type: %T Value: %v\n", ToBe, ToBe)
	fmt.Printf("Type: %T Value: %v\n", MaxInt, MaxInt)
	fmt.Printf("Type: %T Value: %v\n", z, z)
}

5 基本类型

go的基本类型有：

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // alias for uint8

rune // alias for int32
     // represents a Unicode code point

float32 float64

complex64 complex128

整型数字一般使用int类型，除非有特殊的理由使用其他字节长度或无符号的整型。
没有初始化器时，各种类型的默认值：

• 数字类型：0
• bool类型：false
• string类型：""

6 类型转换

当赋值的类型与变量类型不同时，需要类型转换：

var i int = 42
var f float64 = float64(i)
var u uint = uint(f)

或者可以简化为：

i := 42
f := float64(i)
u := uint(f)

注意go没有隐式类型转换，必须使用显示类型转换。

7 类型推断

当我们使用隐式类型声明时，变量类型会根据声明语句右边的值（初始化器）进行推断。

• 当右边的值为已知类型的变量，则左边变量的类型为同一类型：

var i int
j := i // j 也为 int 类型

• 当右边的值为数字字面量常数时，则左边的变量为int, float64, 或 complex128 类型。

i := 42           // int
f := 3.142        // float64
g := 0.867 + 0.5i // complex128

• 当右边的值为bool或string字面量时，左边的变量为相应的类型。

8 常数类型

常数的声明与变量类似，只不过将var关键字改为const，并且不能使用 := 进行声明。
例子：

package main

import "fmt"

const Pi = 3.14

func main() {
	const World = "world"
	fmt.Println("Hello", World)
	fmt.Println("Happy", Pi, "Day")

	const Truth = true
	fmt.Println("Go rules?", Truth)
}

9 数字常数

数字常量为高精度的值。
当数字常量未声明类型时，它的类型不会像变量一样根据右边的值进行推断，而会在使用时根据上下文确定类型。
例子：

package main

import "fmt"

const (
	// Create a huge number by shifting a 1 bit left 100 places.
	// In other words, the binary number that is 1 followed by 100 zeroes.
	Big = 1 << 100
	// Shift it right again 99 places, so we end up with 1<<1, or 2.
	Small = Big >> 99
)

func needInt(x int) int { return x*10 + 1 }
func needFloat(x float64) float64 {
	return x * 0.1
}

func main() {
	fmt.Println(needInt(Small)) // 21
	fmt.Println(needFloat(Small)) // 0.2
	fmt.Println(needFloat(Big)) // 1.2676506002282295e+29
	fmt.Println(needInt(Big)) // 报错：constant 1267650600228229401496703205376 overflows int
}

---

参考文献：
A tour of go
go参考文档
Go’s Declaration Syntax