这是我们 Golang 系列教程的第三篇教程，它涉及到 Golang 中的变量。

你可以阅读 Golang 教程第二部分：Hello World 来学习配置 Go 和运行 hello world 程序。

什么是变量

变量是给内存位置的名称，用来存储特定类型的值。在 Go 中声明变量有多种语法。我们一个一个来看。

声明单个变量

var name type 是声明单个变量的语法。

  1. package main
  3. import "fmt"
  5. func main() {  
  6.     var age int // variable declaration
  7.     fmt.Println("my age is", age)
  8. }

Run in playground

语句 var age int 声明一个名为 _age 的 int _类型的变量。我们没有为变量分配任何值。如果没有为变量赋值，则使用变量类型的零值自动初始化它。在这种情况下，为age 赋值 0。如果运行此程序，则可以看到以下输出

  1. my age is 0

可以将变量分配给其类型的任何值。在下面的程序中，age 可以分配任何整数值。

  1. package main
  3. import "fmt"
  5. func main() {  
  6.     var age int // variable declaration
  7.     fmt.Println("my age is ", age)
  8.     age = 29 //assignment
  9.     fmt.Println("my age is", age)
  10.     age = 54 //assignment
  11.     fmt.Println("my new age is", age)
  12. }

Run in playground

上述程序将产生以下输出。

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

声明具有初始值的变量

当声明一个变量时，也可以为其提供一个初始值。下面是声明一个带有初始值的变量的语法。

  1. var name type = initialvalue
  1. package main
  3. import "fmt"
  5. func main() {  
  6.     var age int = 29 // variable declaration with initial value
  8.     fmt.Println("my age is", age)
  9. }

Run in playground

在上面的程序中，age 是 int 类型的变量，初始值为 29。如果运行上面的程序，可以看到以下输出。

  1. my age is 29

它显示 age 已经初始化为 29。

类型推断

如果变量具有初始值，Go 将自动使用该初始值推断该变量的类型。因此，如果变量具有初始值，变量声明中的 type 可以省略。

如果变量的声明使用了以下语法

  1. var name = initialvalue

Go会根据初始值自动推断出该变量的类型。

在下面的例子中，我们可以看到，在第 6 行中，变量 age 的类型 int 已经被删除。由于该变量的初始值为 29，所以Go 可以推断出它的类型为 int。

  1. package main
  3. import "fmt"
  5. func main() {  
  6.     var age = 29 // type will be inferred
  8.     fmt.Println("my age is", age)
  9. }

Run in playground

多个变量声明

可以在单个语句中声明多个变量。

var name1, name2 type = initialvalue1, initialvalue2 是多个变量声明的语法。

  1. package main
  3. import "fmt"
  5. func main() {  
  6.     var width, height int = 100, 50 //declaring multiple variables
  8.     fmt.Println("width is", width, "height is", height)
  9. }

Run in playground

如果变量有初始值，可以省略类型。由于上面的程序中变量有初始值，所以可以省略 int 类型。

  1. package main
  3. import "fmt"
  5. func main() {  
  6.     var width, height = 100, 50 //"int" is dropped
  8.     fmt.Println("width is", width, "height is", height)
  9. }

Run in playground

以上程序将打印 width is 100 height is 50 作为输出。

你可能已经猜到了，如果没有为 width 和 height 指定初始值，那么它们的初始值将为0。

  1. package main
  3. import "fmt"
  5. func main() {  
  6.     var width, height int
  7.     fmt.Println("width is", width, "height is", height)
  8.     width = 100
  9.     height = 50
  10.     fmt.Println("new width is", width, "new height is ", height)
  11. }

Run in playground

程序将打印

  1. width is 0 height is 0  
  2. new width is 100 new height is  50

在某些情况下，我们可能希望在一个语句中声明属于不同类型的变量。这样做的语法是:

  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. }

Run in playground

这里我们声明一个类型为 string 的变量 name，int 类型的 height 和 age。(在下一篇教程中，我们将讨论 golang 提供的各种类型)。

运行上述程序将打印 

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

简短的声明

Go 还提供了另一种声明变量的简洁方法。这就是所谓的简短声明，它使用 := 操作符。

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

  1. package main
  3. import "fmt"
  5. func main() {  
  6.     count := 10
  7.     fmt.Println("Count =",count)
  8. }

Run in playground

上面程序将打印，

  1. Count = 10


也可以使用简短语法语法在单行中声明多个变量。

  1. package main
  3. import "fmt"
  5. func main() {  
  6.     name, age := "naveen", 29 //short hand declaration
  8.     fmt.Println("my name is", name, "age is", age)
  9. }

Run in playground

上面的程序声明了两个变量，分别是 string 和 int 类型的 name 和 age。

如果你运行上面的程序，你可以看到 my name is naveen age is 29 被打印出来。

简短声明要求所有变量的初始值都在赋值的左侧。下面的程序会打印一个错误 assignment mismatch: 2 variables but 1 values。这是因为 age 没有被赋值。

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

Run in playground

只有当 := 左边的变量中至少有一个是新声明的，才能使用简短语法。思考下面这个程序。

  1. package main
  2. import "fmt"
  3. func main() {  
  4.     a, b := 20, 30 // declare variables a and b
  5.     fmt.Println("a is", a, "b is", b)
  6.     b, c := 40, 50 // b is already declared but c is new
  7.     fmt.Println("b is", b, "c is", c)
  8.     b, c = 80, 90 // assign new values to already declared variables b and c
  9.     fmt.Println("changed b is", b, "c is", c)
  10. }

Run in playground

在上面的程序里第 8 行，b 已经被声明但是 c 是新声明的，因此它将输出

  1. a is 20 b is 30  
  2. b is 40 c is 50  
  3. changed b is 80 c is 90

而如果我们运行下面的程序

  1. package main
  3. import "fmt"
  5. func main() {  
  6.     a, b := 20, 30 //a and b declared
  7.     fmt.Println("a is", a, "b is", b)
  8.     a, b := 40, 50 //error, no new variables
  9. }

Run in playground

它会抛出错误 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 := 145.8, 543.8
  10.     c := math.Min(a, b)
  11.     fmt.Println("minimum value is ", c)
  12. }

Run in playground

在上面的程序中，math 是一个 package，Min 是该包中的一个函数。现在不用担心，我们会在接下来的教程中详细讨论 packages 和 functions。我们需要知道的是，c　的值是在运行时计算出来的，它是 a 和 b 的之间的最小值，上面的程序会打印出来。

  1. minimum value is  145.8

由于 Go 是强类型的，因此声明属于一种类型的变量不能赋予另一种类型的值。以下程序将抛出错误 cannot use "naveen" (type string) as type int in assignment 因为 age 被声明为 int 类型，而我们正在尝试为它分配一个 string 类型的值。

  1. package main
  3. func main() {  
  4.     age := 29      // age is int
  5.     age = "naveen" // error since we are trying to assign a string to a variable of type int
  6. }

Run in playground

原文链接

https://golangbot.com/variables/