一起来学Go --- (go的变量)

变量

变量是几乎所有编程语言中最基本的组成元素，从根本上说，变量相当于是一块数据存储空间的命名，程序可以通过定义一个变量来申请一块数据存储空间，之后可以通过引用变量名来使用这块存储空间。go语言中的变量使用方式与C语言接近，但具备更大的灵活性。

变量的声明

　　go语言引入了关键字ver，而类型信息放在变量名之后。示例如下：

var v1 int

var v2 string

var v3 [10]int    //数组

var v4 []int        //数组切片

var v5 struct  {
       f int
        }            

var v6 *int        // 指针

var v7 map[strint]int     //map,key为string类型，value为int类型

var v8 func(a int) int

　　

变量声明语句不需要使用分号作为结束语，与C语言相比，go语言摒弃了语句必须以分号作为语句结束标记的习惯。

var关键字的另一种用法是可以将若干个需要声明的变量放置在一起，免得程序员需要重复写var关键字，如下图：

var (
      v1 int
      v2 string
)

变量初始化

　　对于声明变量时需要进行初始化的场景，var关键字可以保留，但不再是必要的元素，如下所示：

//正确的使用方式1
var v1 int =10

//正确的使用方式2，编译器可以自动推导出v2的类型
var v2 = 10

//正确的使用方式3，编译器可以自动推导出v3的类型
v3 := 10

　　以上三种用法的效果是一样的，与第一种用法相比，第三种用法需要输入的字符数大大减少，这里go语言也引入了另一个c和c++中没有的符号(冒号和等号的组合:=)，用于明确表达同时进行变量声明和初始化的工作。

指定类型已不再是必须得，go编译器可以从初始化表达式的右值推导出该变量应该声明为那种类型，这让go语言看起来有点像 动态类型语言，尽管go语言实际上是不折不扣的强类型语言(静态类型语言)

当然，出现  :=左侧的变量不应该是已经被声明过的，否则会导致编译错误，比如下面这个：

var i int
i := 2

会导致类似如下的编译错误

no new variables on left side of :=

变量赋值

　　在go语法中，变量初始化和变量赋值是两个不同的概念，下面为声明一个变量之后的赋值过程:

var  v10  int
v10 = 123

　　go语言的变量赋值与多数语言一直，但go语言中 提供了c/c++程序员期盼多年的多重赋值功能，比如下面这个交换  i  和  j   变量的语句：

i , j = j , i
在不支持多重赋值的语言中，交互两个变量的内容需要 引入一个中间变量。

t = i; i = j; j = t;

　　多重赋值的特性在go语言库的实现中也被使用得相当充分，在介绍函数的多重返回值时，将对其进行更加深入的介绍 ，总而言之 ，多重赋值功能让go语言与C/C++语言相比非常明显地减少代码行数 。

匿名变量

　　我们在使用传统的强类型语言编程时，经常会出现这种情况，即在调用函数 时为了获取一个值，却应为该函数返回多个值而不得不定义一堆没用的变量，在go中这种情况可以通过结合使用多重返回和匿名变量来避免这种丑陋的写法，让代码看起来更加优雅。

假设：GetNmae()函数的定义如下，它返回三个值，分别为 firstName、lastName和nickName：

func GetName() (firstName, lastName, nickName string) {
      return "may", "Hello", "World"
}

　　若只想获得nickName，则函数调用语句可以用如下方式编写：

_, _, nickName := GetName()

　　这种用法可以让代码非常清晰，基本上屏蔽掉了可能混淆大家实现的内容，从而大幅度降低沟通的复杂度和代码为何的难度。

常量

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

字面常量

所谓字面常亮(literal),是指程序中硬编码的常量，如：

-12
3.14159265358979323856    //浮点类型的常量
3.2+12i                                //复数类型常量
true                                      //布尔类型常量
"foo"                                     //字符串常量

　　只要这个常量在响应类型的值域范围内，就可以作为该类型的常量。

 常量的定义

通过const关键字，你可以给字面常亮指定一个很友好的名字：

const Pi float64 = 3.14159265358979323846

const zero = 0.0       //无类型浮点常量

const (
     size int64 = 1024
     eof = -1              //无类型整数常量
)

const u, v float32 = 0, 3 // u = 0.0, v = 3.0, 常量的多场赋值

const a, b, c = 3, 4, "foo"

// a = 3, b = 4, c = "foo"     ,无类型整型和字符串常量

　　go的常量定义可以限定类型，但不是必须的，如果定义常量时没有指定类型，那么它与字面常量一样，是无类型常量。

预定义常量

　　go的语言预定义了这些常量： true ，  false和iota。

iota比较特殊，可以认为是一个可被编译器修改的常量，在每一个const关键字出现时被重置为0，然后在下一个const出现之前，每出现一次iota，其 所代表的数字会自动增1。

从以下列子当中可以基本理解iota的用法：

const(                     // iota被重设为0
    c0 = iota             // c0 == 0
    c1 = iota             // c1 == 0
    c2 = iota             // c2 == 0
)

const (
       a = 1 << iota     // a ==1 (iota在每个const开头被重设为0)
       b = 1 << iota     // b == 2
       c = 1 << iota     // c == 4
)

const (
      u    = iota * 42      // u == 0          iota在每个const开头被重设为0
      v  float64  = iota * 42    // b == 2
      c = 1 << iota         // c == 4

)

const(
    u        = iota * 42      // u == 0
    v float64 = iota * 42  // v == 42.0
    w        = iota * 42     // w == 84

)

const x = iota       //  x == 0 itao又被重设为0

const y = iota       // y == 0 同上

　　如果两个const的赋值语句的表达式是一样的，那么可以省略后一个赋值表达式，因此，上面的前两个const语句可简写为：

const (
        c0 = iota         // iota被重设为0
        c1                   // c1 == 1
        c2                   // c2 == 2
)    

const (
        a = 1 << iota            // a == 1
        b                              // b == 2
        c                              // c == 4

)

　　小结： 本章只是学习go的基本的变量，变量的定义，常量等。

定义变量关键字：    var

定义常量关键字 ：   const