go系列教程-变量

go语言是静态类型语言，因此变量（variable）是有明确类型的，编译器也会检查变量类型的正确性。在数学概念中，变量表示没有固定值且可改变的数。但从计算机系统实现角度来看，变量是一段或多段用来存储数据的内存。

1、变量是什么？

变量指定了某存储单元（memory location）的名称，该存储单元会存储特定类型的值。在 go 中，有多种语法用于声明变量。

 

2、声明单个变量

 （2.1）var name type 声明单个变量的语法

package main

import "fmt"

func main() {
　　// 变量声明
    var age int
    fmt.println("my age is", age)
}

在线运行程序

my age is 0

语句 var age int 声明了一个 int 类型的变量，名字为 age。我们还没有给该变量赋值。如果变量未被赋值，go 会自动地将其初始化，赋值该变量类型的零值（zero value）。本例中 age 就被赋值为 0。如果你运行该程序。

 

变量可以赋值为本类型的任何值。上一程序中的 age 可以赋值为任何整型值（integer value）。

package main

import "fmt"

func main() {
    // 变量声明
    　var age int
    fmt.println("my age is", age)
    // 赋值
       age = 29
    fmt.println("my age is", age)
    // 赋值
       age = 35
    fmt.println("my age is", age)
}

在线运行程序  

my age is 0
my age is 29
my age is 35

 

（2.2）声明变量并初始化

声明变量的同时可以给定初始值
var name type = initialvalue 的语法用于声明变量并初始化。

package main

import "fmt"

func main() {
    // 声明变量并初始化
    var age int = 29

  fmt.println("my age is", age)
}

在线运行程序

my age is 29

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

 

（2.3）类型推断（type inference）

如果变量有初始值，那么 go 能够自动推断具有初始值的变量的类型。因此，如果变量有初始值，就可以在变量声明中省略 type。

如果变量声明的语法是 var name = initialvalue，go 能够根据初始值自动推断变量的类型。

在下面的例子中，你可以看到在第 6 行，我们省略了变量 age 的 int 类型，go 依然推断出了它是 int 类型。

package main

import "fmt"

func main() {
    var age = 29 // 可以推断类型

    fmt.println("my age is", age)
}

 

3、声明多个变量

（3.1）go 能够通过一条语句声明多个变量。  声明多个变量的语法是 var name1, name2 type = initialvalue1, initialvalue2。

package main

import "fmt"

func main() {  
    var width, height int
    fmt.println("width is", width, "height is", height)
    width = 100
    height = 50
    fmt.println("new width is", width, "new height is ", height)
}

在线运行程序

width is 0 height is 0  
new width is 100 new height is  50

 

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

var (  
    name1 = initialvalue1,
    name2 = initialvalue2
)

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

package main

import "fmt"

func main() {
    var (
        name   = "naveen"
        age    = 29
        height int
    )
    fmt.println("my name is", name, ", age is", age, "and height is", height)
}

在线运行程序 

my name is naveen , age is 29 and height is 0

这里我们声明了 string 类型的 name、int 类型的 age 和 height

 

4、简短声明（推荐使用）

（4.1）go 也支持一种声明变量的简洁形式，称为简短声明（short hand declaration），该声明使用了 := 操作符。

声明变量的简短语法是 name := initialvalue。

package main

import "fmt"

func main() {  
    name, age := "naveen", 29 // 简短声明

    fmt.println("my name is", name, "age is", age)
}

在线运行程序

my name is naveen age is 29

简短声明要求 := 操作符左边的所有变量都有初始值。下面程序将会抛出错误 cannot assign 1 values to 2 variables，这是因为 age 没有被赋值

 

（4.2）简短声明的语法要求 := 操作符的左边至少有一个变量是尚未声明的。考虑下面的程序：

package main

import "fmt"

func main() {
    a, b := 20, 30 // 声明变量a和b
    fmt.println("a is", a, "b is", b)
    b, c := 40, 50 // b已经声明，但c尚未声明
    fmt.println("b is", b, "c is", c)
    b, c = 80, 90 // 给已经声明的变量b和c赋新值
    fmt.println("var b is", b, "c is", c)
}

在线运行程序

a is 20 b is 30  
b is 40 c is 50  
changed b is 80 c is 90

但是如果我们运行下面的程序:

package main

import "fmt"

func main() {  
    a, b := 20, 30 // 声明a和b
    fmt.println("a is", a, "b is", b)
    a, b := 40, 50 // 错误，没有尚未声明的变量
}

在线运行程序

上面运行后会抛出 no new variables on left side of := 的错误，这是因为 a 和 b 的变量已经声明过了，:= 的左边并没有尚未声明的变量。

变量也可以在运行时进行赋值。考虑下面的程序：

package main

import (  
    "fmt"
    "math"
)
func main() {  
    a, b := 145.8, 543.8
    c := math.min(a, b)
    fmt.println("min mum value is ", c)
}

在线运行程序

min mum value is  145.8

 

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

package main

func main() {  
    age := 29      // age是int类型
    age = "wide" // 错误，尝试赋值一个字符串给int类型变量
}

 

总结

1、go语言的变量声明的标准格式为：

var 变量名 变量类型

变量声明以关键字 var 开头，后置变量类型，行尾无须分号。

2、批量格式：

觉得每行都用 var 声明变量比较烦琐？没关系，还有一种为懒人提供的定义变量的方法：

var (
    a int
    b string
    c []float32
    d func() bool
    e struct {
        x int
    }
)

使用关键字 var 和括号，可以将一组变量定义放在一起。

3、简短格式

除 var 关键字外，还可使用更加简短的变量定义和初始化语法

名字 := 表达式

需要注意的是，简短模式（short variable declaration）有以下限制：

(1)、定义变量，同时显式初始化。

(2)、不能提供数据类型。

(3)、只能用在函数内部。