什么是变量？

变量相当于内存中的一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，同样的道理，通过变量名，程序可以访问到变量的值。

变量分类（作用域）

全局变量

在Go函数外部定义的变量，即为 全局变量（所有函数都可以调用）

  1. // 案例演示的是 全局变量
  2. package main
  3. import "fmt"
  4. var a = 123 // 注意全局变量不能使用 := 来声明变量和赋值
  5. // 批量定义全局或局部变量时，也可以采用如下方式
  6. var (
  7.     b = "name"
  8.     c = "true"
  9. )
  10. func main(){
  11.     fmt.Println("a =",a,"b =",b,"c =",c)
  12. }

注意：全局变量不能使用 := 来声明变量并赋值
image.png

局部变量

在Go函数内部定义的变量，即为 局部变量（只有函数内部可以调用）

  1. // 案例演示的是 局部变量
  2. package main
  3. import "fmt"
  4. func main(){
  5.     var a := 123 // 局部变量才可以使用 := 来声明变量和赋值
  6.     fmt.Println("a =",a)
  7. }

注意：只有局部变量才可以使用 := 来声明变量并赋值

变量三步骤

  • 变量声明（或叫变量定义）
  • 变量赋值
  • 变量使用

    变量初始化 = 变量声明 + 变量赋值

快速入门

  1. // 演示变量使用案例
  2. package main
  3. import "fmt"
  4. func main(){
  5.     var i int //声明一个变量i，int为变量类型
  6.     i = 100 //给变量i赋值
  7.     fmt.Println("i =", i) //使用变量i
  8. }

注意事项

  • 变量表示内存中的一个存储区域
  • 该区域有自己的名称（变量名）和 类型（数据类型）
  • 不同数据类型的变量之间，不能直接赋值（例如把float类型的变量值 直接 赋给int类型的变量，是不允许的）
    1. package main
    2. import "fmt"
    3. func main(){
    4.   var i int
    5.   i = 100 // 此时变量i是int类型
    6.   fmt.Println("i =", i)
    7.   i = 3.14 // 3.14属于float类型，和i之前的int类型定义冲突，编译器会报错
    8.   fmt.Println("i =", i)
    9. }

    变量初始化

    变量初始化 = 变量声明 + 变量赋值

变量声明后，若不赋值，则变量为默认值

变量数据类型 默认值
int 整数型 0
float 浮点数 0
string 字符串 “” 即为空
bool 布尔型 false

指定数据类型

  1. // 演示指定数据类型并赋值
  2. package main
  3. import "fmt"
  4. func main(){
  5.     var a int
  6.     var b float32
  7.     var c float64
  8.     var d string
  9.     var e bool
  10.     fmt.Println("a =", a)
  11.     fmt.Println("b =", b)
  12.     fmt.Println("c =", c)
  13.     fmt.Println("d =", d)
  14.     fmt.Println("d =", e)
  15. }

类型推导

根据变量值，编译器会自行判断变量的数据类型（即：类型推导）

  1. // 演示数据类型推导
  2. package main
  3. import "fmt"
  4. func main(){
  5.     var a = -11.11
  6.     fmt.Printf("a的变量类型是%T\n", a)
  7. }

简短声明（仅限局部变量）

省略var，使用:=来声明变量并赋值

  1. // 演示简洁声明
  2. package main
  3. import "fmt"
  4. func main(){
  5.     a := 123
  6.     b := true
  7.     fmt.Println("a =", a)
  8.     fmt.Println("b =", b)
  9. }

变量批量初始化

在编程中，有时我们需要一次性申明多个变量，Go中也是支持批量声明变量的

相同类型批量声明

  1. // 批量声明-方式1（批量声明的变量具有相同的数据类型）
  2. package main
  3. import "fmt"
  4. func main(){
  5.     var a,b,c,d int
  6.     a = 1
  7.     b = 2
  8.     c = 3
  9.     d = 4
  10.     fmt.Println("\n","a =",a,"\n","b =",b,"\n","c =",c,"\n","d =",d)
  11. }

相同类型批量声明并赋值

  1. // 批量声明-方式2（批量声明的变量具有相同的数据类型）
  2. package main
  3. import "fmt"
  4. func main(){
  5.     var a,b,c,d int = 1,2,3,4
  6.     fmt.Println("\n","a =",a,"\n","b =",b,"\n","c =",c,"\n","d =",d)
  7. }

不同数据类型批量声明并赋值

  1. // 批量声明-方式3（批量声明的变量具有不相同的数据类型）
  2. package main
  3. import "fmt"
  4. func main(){
  5.     var a, b, c, d  = 1, "string", true, 3.14
  6.     fmt.Println("\n","a =",a,"\n","b =",b,"\n","c =",c,"\n","d =",d)
  7. }

不同数据类型批量简洁声明并赋值

  1. // 批量声明-方式4（批量简洁声明的变量具有不相同的数据类型）
  2. package main
  3. import "fmt"
  4. func main(){
  5.     a, b, c, d  := 1, "string", true, 3.14
  6.     fmt.Println("\n","a =",a,"\n","b =",b,"\n","c =",c,"\n","d =",d)
  7. }