变量

使用一个名词来代表一块内存地址，该内存地址存放的数据类型由定义变量时声明的类型确定，变量意味着存放的数据是可以被修改的。

Var完整声明

声明开头是一个字母( Unicode 中的字符即可)或下划线，后面可以跟任意数量的字符 、 数字和下划线，并区分大小写 。 如 x和 X是不同的变量名称
使用var关键字是Go最基本的定义变量方式，Go把变量类型放在变量名后面。

  1. var 变量名称 数据类型 [ = 变量初始值]

声明了一个 int 类型的变量，名字为 age的变量如下所示

  1. var age int // 变量声明

注意 GO声明的变量就会立即分配内存空间，也就意味着会被默认初始化值
如果一个变量未被赋值，Go 会自动地将其初始化，赋值该变量类型的零值（Zero Value)。上面的声明是没有对age变量赋值，int 类型默认值是0， 因此age就被赋值为 0。

  1. package main
  2. import "fmt"
  3. func main() {
  4.     var age int // 变量声明
  5.     fmt.Println("my age is", age)
  6.     age = 1 // 赋值
  7.     fmt.Println("my age is", age)
  8.     age = 2 // 赋值
  9.     fmt.Println("my new age is", age)
  10. }

上面的程序会有如下输出：

  1. my age is  0  
  2. my age is 1  
  3. my new age is 2

类型推断（Type Inference）

如果变量有初始值，那么 Go 能够自动推断具有初始值的变量的类型。因此，如果变量有初始值，就可以在变量声明中省略 type。
如果变量声明的语法是 var name = initialvalue，Go 能够根据初始值自动推断变量的类型。
在下面的例子中，你可以看到在第 6 行，我们省略了变量 age 的 int 类型，Go 依然推断出了它是 int 类型。

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var age = 9 // 可以推断类型
  7.     fmt.Println("my age is", age)
  8. }

声明变量的同时可以给定初始值。

  1. var 变量名称 变量类型 = 变量初始化值

eg:

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var age int = 29 // 声明变量并初始化
  7.     fmt.Println("my age is", age)
  8. }

在上面的程序中，age 是具有初始值 29 的 int 类型变量。如果你运行上面的程序，你可以看见下面的输出，证实 age 已经被初始化为 29。

  1. my age is 29

:=简短声明

Go支持一种用了 := 声明变量的形式，称为短变量声明（Short Hand Declaration）

  1. name := initialvalue

不过短变量声明有一个限制，那就是它适用于函数 / 方法内部或是 if、for 和 switch 的初始化语句中；在函数外部使用则会无法编译通过，所以一般用var方式来定义全局变量。

  1. package main
  3. import "fmt"
  5. func main() {  
  6.     name, age := "xiang", 18 // 简短声明
  7.     fmt.Println("my name is", name, "age is", age)
  8. }

运行上面的程序，可以看到输出为 my name is xiang age is 18。
简短声明要求 := 操作符左边的所有变量都有初始值。下面程序将会抛出错误 cannot assign 1 values to 2 variables，这是因为 age 没有被赋值。

  1. package main
  3. import "fmt"
  5. func main() {  
  6.     name, age := "naveen" //error
  7.     fmt.Println("my name is", name, "age is", age)
  8. }

简短声明的语法要求 := 操作符的左边至少有一个变量是尚未声明的。下面的程序中a,b 已经被声明 所以再次声明ab是错误的

  1. package main
  2. import "fmt"
  4. func main() {  
  5.     a, b := 2, 3 // 声明a和b
  6.     fmt.Println("a is", a, "b is", b)
  7.     a, b := 4, 5 // 错误，没有尚未声明的变量
  8. }

上面运行后会抛出 no new variables on left side of := 的错误，这是因为 a 和 b 的变量已经声明过了，:= 的左边并没有尚未声明的变量。
变量可以被函数返回值时进行赋值。下面程序中

  1. package main
  3. import (
  4.     "fmt"
  5.     "math"
  6. )
  8. func main() {
  9.     a, b := 1.0, 2
  10.     c := math.Min(a, float64(b))
  11.     fmt.Println("minimum value = ", c)
  12. }

在上面的程序中，c 的值是math.Min函数返回的结果，表示 a 和 b 的最小值。打印结果

  1. minimum value =  1

同时要区分好简短声明的是变量只能在函数内部使用，下面的a 分为全局和本地变量 需要分清楚

  1. package main
  3. import "fmt"
  5. var a int
  7. func foo() (int, int) {
  8.     return 10, 20
  9. }
  11. func bar() {
  12.     fmt.Printf("global a = %d\n", a)
  13. }
  15. func main() {
  16.     a, _ := foo()
  17.     fmt.Printf("local a = %d\n", a)
  18.     bar()
  19. }

上面的程序执行结果是

  1. local a = 10
  2. global a = 0

由于 Go 是强类型（Strongly Typed）语言，因此不允许某一类型的变量赋值为其他类型的值。下面的程序会抛出错误 cannot use "naveen" (type string) as type int in assignment，这是因为 age 本来声明为 int 类型，而我们却尝试给它赋字符串类型的值。

  1. package main
  3. func main() {  
  4.     age := 29      // age是int类型
  5.     age = "naveen" // 错误，尝试赋值一个字符串给int类型变量
  6. }

多个变量

Go 能够通过一条语句声明多个变量。声明多个变量的语法是 ：

  1. var 变量名1, 变量名2 <变量类型> = 初始值1,初始值2
  1. package main
  3. import "fmt"
  5. func main() {
  6.     var a, b = 2, 3
  7.     fmt.Printf("a=%d b=%d\n", a, b)
  8.     a, b = b, a
  9.     fmt.Printf("a=%d b=%d\n", a, b)
  10. }

上面的程序将会打印：

  1. a=2 b=3
  2. a=3 b=2

在有些情况下，我们可能会想要在一个语句中声明不同类型的变量。其语法如下：

  1. var (  
  2.     name1 = initialvalue1,
  3.     name2 = initialvalue2
  4. )

使用上述语法，下面的程序声明不同类型的变量。

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var (
  7.         name   = "naveen"
  8.         age    = 29
  9.         height int
  10.     )
  11.     fmt.Println("my name is", name, ", age is", age, "and height is", height)
  12. }

这里我们声明了 string 类型的 name、int 类型的 age 和 height（我们将会在下一教程中讨论 golang 所支持的变量类型）。运行上面的程序会产生输出

  1. my name is naveen , age is 29 and height is 0。

_忽略变量

_（下划线）是个特殊的变量名，任何赋予它的值都会被丢弃。在这个例子中，我们将值2赋予b，并同时丢弃1：

  1. _, b := 1, 2
  • 包导入
    主要是调用init 函数（比如数据库驱动的注册） ```go

import ( _ “github.com/mydemo/dbdriver” )

  2. - 返回值 <br />主要是忽略某个值
  3. ```go
  6. _,err := callFunc()
  • 类型约定
    比如判断某个struct是否实现接口的方法
    比如判断 type T是否实现了I,用作类型断言，如果T没有实现借口I，则编译错误.
  1. type T struct{}
  2. var _ I = T{}
  4. 其中 I为interface

常量

定义

关键字 const 被用于表示常量，常量用于存储不会改变的数据，常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。常量存储在程序的只读段里（.rodanat section)

  1. const identifier [type] = value

常量不能再重新赋值为其他的值

  1. const a = 55 // 允许
  2.     a = 89       // 不允许重新赋值

常量的值会在编译的时候确定。因为函数调用发生在运行时，所以不能将函数的返回值赋值给常量。

  1. package main
  3. import (  
  4.     "fmt"
  5.     "math"
  6. )
  8. func main() {  
  9.     fmt.Println("Hello, playground")
  10.     var a = math.Sqrt(4)   // 允许
  11.     const b = math.Sqrt(4) // 不允许
  12. }

在上面的程序中，因为 a 是变量，因此我们可以将函数 math.Sqrt(4) 的返回值赋值给它（我们将在单独的地方详细讨论函数）。
b 是一个常量，它的值需要在编译的时候就确定。函数 math.Sqrt(4) 只会在运行的时候计算，因此 const b = math.Sqrt(4) 将会抛出错误 error main.go:11: const initializer math.Sqrt(4) is not a constant)

枚举

常量还可以用作枚举, 如下数字 0、1 和 2 分别代表未知性别、女性和男性

  1. const (
  2.     Unknown = 0
  3.     Female = 1
  4.     Male = 2
  5. )

iota

预声明标识符iota，它默认开始值是0，一组多个常量同时声明时其值逐行递增， iota常用来表示自增的枚举变量，专门用来初始化常量。 

  1. const (
  2.     x = iota // x == 0
  3.     y  // y == 1
  4.     z  // z == 2
  5.     w //w ==3
  6. )
  7. func main() {
  8.     fmt.Println(x,y,z,w)
  9. }

位运算方式

  1. const (
  2.     Open = 1 << iota //1
  3.     Close //2
  4.     Pending //4
  5. )

关键字

Go 代码中会使用到的 25 个关键字或保留字：

break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var