Go变量、常量和作用域

变量

变量是几乎所有编程语言中最基本的组成元素。从根本上说，变量相当于是对一块数据存储空间的命名，程序可以通过定义一个变量来申请一块数据存储空间，之后可以通过引用变量名来使用这块存储空间。

var声明语句可以创建一个特定类型的变量，然后给变量附加一个名字，并且设置变量的初始 值。变量声明的一般语法如下：

var 变量名字 类型 = 表达式
定义变量并进行初始化，例如：var name string = "silence"

var 变量名 变量类型
定义变量使用零值进行初始化，例如：var age int

var 变量名 = 值
定义变量，变量类型通过值类型进行推导.例如： var isBoy = true

var 变量名 1, 变量名 2 , …, 变量名 n 变量类型
定义多个相同类型的变量并使用零值进行初始化.例如：var prefix, suffix string

var 变量名 1, 变量名 2 , …, 变量名 n 变量类型 = 值 1, 值 2, …, 值 n
定义多个相同类型的变量并使用对应的值进行初始化，例如：var prev, next int = 3, 4

var 变量名 1, 变量名 2 , …, 变量名 n = 值 1, 值 2, …, 值 n
定义多个变量并使用对应的值进行初始化，变量的类型使用值类型进行推导，类型可不相同，例如：var name, age = "silence", 30

批量定义
var (
    变量名 1 变量类型 1 = 值 1
    变量名 2 变量类型 2 = 值 2 
)
定义多个变量并进行初始化，批量复制中变量类型可省略
例如：
var (
    name string = "silence"
    age int = 30
)

初始化表达式可以使用字面量、任何表达式、函数

package main

import "fmt"

var v0 int
var v1 int = 1
var v2 = 2

var v3, v4 int = 3, 4

var v5, v6 = "5", 6

func main() {
	var (
		v7 int = 2 + 5
		v8 int = v2 + v6
	)
	fmt.Println(v0, v1, v2, v3, v4, v5, v6, v7, v8)	//0 1 2 3 4 5 6 7 8
}

简短变量声明

在函数内部，有一种称为简短变量声明语句的形式可用于声明和初始化局部变量。它以“名字 := 表达式”形式声明变量，变量的类型根据表达式来自动推导。

t := 0.0
i := 100	// 注意等号前的冒号

简式声明一般用在func内，要注意的是：全局变量和简式声明的变量尽量不要同名，否则很容易产生偶然的变量隐藏

即使对于经验丰富的Go开发者而言，这也是一个非常常见的陷阱。这个坑很容易挖，但又很难发现。

func main() {  
    x := 1
    fmt.Println(x)     // 1
    {
        fmt.Println(x) //  1
        x := 2
        fmt.Println(x) //  2
    }
    fmt.Println(x)     //  1 (不是2)
}

赋值

想要交换两个变量的值，则可以简单地使用：

a, b = b, a
这样省去了使用交换函数的必要

空白标识符

空白标识符 也被用于抛弃值

_, b = 5, 7	//5被抛弃

_ 实际上是一个只写变量，你不能得到它的值。这样做是因为 Go 语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值。

由于Go语言有个强制规定，在函数内一定要使用声明的变量，但未使用的全局变量是没问题的。为了避免有未使用的变量，代码将编译失败，我们可以将该未使用的变量改为 _。

另外，在Go语言中，如果引入的包未使用，也不能通过编译。有时我们需要引入的包，比如需要init()，或者调试代码时我们可能去掉了某些包的功能使用，你可以添加一个下划线标记符，_，来作为这个包的名字，从而避免编译失败。下滑线标记符用于引入，但不使用。

package main
import (  
    _ "fmt"
    "log"
    "time"
)
var _ = log.Println
func main() {  
    _ = time.Now
}

零值nil

nil 标志符用于表示interface、函数、maps、slices和channels的“零值”。如果你不指定变量的类型，编译器将无法编译你的代码，因为它猜不出具体的类型。

package main
func main() {  
    var x = nil // 错误
    _ = x
}

字符串不会为 nil

var s string  = "" // ""是字符串的零值
var str string	// 也是字符串的零值

常量

在Go语言中，常量是指编译期间就已知且不可改变的值。常量可以是数值类型（包括整型、浮点型和复数类型）、布尔类型、字符串类型等。

字面常量

所谓字面常量（literal），是指程序中硬编码的常量，如：

-12		//整型 

3.14159265358979323846 // 浮点类型的常量

3.2+12i // 复数类型的常量

true // 布尔类型的常量

"foo" // 字符串常量

在其他语言中，常量通常有特定的类型，比如-12在C语言中会认为是一个int类型的常量。如果要指定一个值为-12的long类型常量，需要写成-12l，这有点违反人们的直观感觉。Go语言的字面常量更接近我们自然语言中的常量概念，它是无类型的。只要这个常量在相应类型的值域范围内，就可以作为该类型的常量，比如上面的常量-12，它可以赋值给int、uint、int32、int64、float32、float64、complex64、complex128等类型的变量。

常量定义

常量用于定义不可被修改的的值，需要在编译过程中进行计算，只能为基础的数据类型布尔、数值、字符串，使用 const 进行常量声明，常量声明必须初始化值

常用语法：

const 常量名 类型 = 值
定义常量并进行初始化，例如：const pi float64 = 3.1415926

const 常量名 = 值
定义常量，类型通过值类型进行推导，例如：const e = 2.7182818

批量定义
const (
	常量名 1 类型 1 = 值 1 常量名 2 类型 2 = 值 2 
	)
定义多个变量并进行初始化，批量复制中变量类型可省略，并且除了第一个常量值外其他常量可同时省略类型和值，表示使用前一个常量的初始化表达式
例如：
const (
    name string = "silence"
    age int = 30
)
const (
    name string = "silence"
    desc
)

常量之间的运算，类型转换，以及对常量调用函数 len、cap、real、imag、complex、unsafe.Sizeof 得到的结果依然为常量

package main

import "fmt"

const c0 int = 0

const c1 int = 1
const c2 = 3 -1
const c3, c4 int = 3, 4
const c5, c6 = "5", c4 + c2

func main() {
	const (
		c7 int = 7
		c8
	)
	fmt.Println(c0, c1, c2, c3, c4, c5, c6, c7, c8)	//0 1 2 3 4 5 6 7 7
}

枚举iota

常使用iota生成器用于初始化一系列相同规则的常量，批量声明常量的第一个常量的使用iota进行赋值，此时 iota 被重置为 0，其他常量省略类型和赋值，在每初始化一个常量则加 1

iota()以内从0开始，如果另一个()内也是iota,则重新从0开始

const (
	i1 int = iota
	i2
	i3 int = iota
	i4
)

func main() {
	//  枚举
	const (
		i5 = iota
		i6
		i7 = 7
		i8 = iota
		i9
	)

	fmt.Println(i1, i2, i3, i4, i5, i6, i7, i8, i9)	//0 1 2 3 0 1 7 3 4

}

作用域

作用域指变量可以使用范围，就近原则。go 语言使用大括号显示的标识作用域范围，大括号内包含一连串的语句，叫做语句块。语句块可以嵌套，语句块内定义的变量不能在语句块外使用

局部变量

在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，参数和返回值变量也是局部变量。

package main

import "fmt"

func main() {
   /* 声明局部变量 */
   var a, b, c int 

   /* 初始化参数 */
   a = 10
   b = 20
   c = a + b

   fmt.Printf ("结果： a = %d, b = %d and c = %d
", a, b, c)	//结果： a = 10, b = 20 and c = 30
}

全局变量

作用域是全局的（在本包范围内）
在函数体外声明的变量称之为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用。全局变量可以在任何函数中使用。

package main

import "fmt"

/* 声明全局变量 */
var g int

func main() {

   /* 声明局部变量 */
   var a, b int

   /* 初始化参数 */
   a = 10
   b = 20
   g = a + b

   fmt.Printf("结果： a = %d, b = %d and g = %d
", a, b, g)	//结果： a = 10, b = 20 and g = 30
}

简式变量

使用 := 定义的变量，如果新变量p与那个同名已定义变量 (这里就是那个全局变量p)不在一个作用域中时，那么Go 语言会新定义这个变量p，遮盖住全局变量p。刚开始很容易在此犯错而茫然，解决方法是局部变量尽量不同名，限定标识符使用的范围。

注意，简式变量只能在函数内部声明使用，但是它可能会覆盖函数外全局同名变量。而且你不能在一个单独的声明中重复声明一个变量，但在多变量声明中这是允许的，而且其中至少要有一个新的声明变量。重复变量需要在相同的代码块内，否则你将得到一个隐藏变量。

如果你在代码块中犯了这个错误，将不会出现编译错误，但应用运行结果可能不是你所期望。所以尽可能避免和全局变量同名。

常见隐式语句块

	全语句块

​	包语句块

​	文件语句块

​	if、switch、for、select、case 语句块

作用域内定义变量只能被声明一次且变量必须使用，否则编译错误。在不同作用域可定义相同的变量，此时局部将覆盖全局

package main

import "fmt"

func main() {
	outer := 1
	{
		inner := 2
		fmt.Println(outer, inner)	//1 2
		outer := 3
		fmt.Println(outer, inner)	//3 2	寻找由内向外
	}
	//fmt.Println(inner)	//使用原则: 子语句块可以使用父语句块中的标识符,父不能用子的
	fmt.Println(outer)	//1
}

形式参数

形式参数会作为函数的局部变量来使用

package main

import "fmt"

/* 声明全局变量 */
var a int = 20;

func main() {
   /* main 函数中声明局部变量 */
   var a int = 10
   var b int = 20
   var c int = 0

   fmt.Printf("main()函数中 a = %d
",  a);	//main()函数中 a = 10
   c = sum( a, b);
   fmt.Printf("main()函数中 c = %d
",  c);	//main()函数中 c = 30
}

/* 函数定义-两数相加 */
func sum(a, b int) int {
   fmt.Printf("sum() 函数中 a = %d
",  a);	//sum() 函数中 a = 10
   fmt.Printf("sum() 函数中 b = %d
",  b);	//sum() 函数中 b = 20

   return a + b;
}