GO语言的变量

GO语言的变量

(1)变量的声明:

一、指定变量类型(如果不赋值,会有默认值):

1
2
3
4
5
var v_name v_type

var test1 string //没赋值,初始值为""空字符串
var test2 int //没赋值,初始值为0
var test3 string = "test2" //赋值了,为"test2" String

二、根据值自行判定变量的类型:

1
2
3
var v_name = value

var test4 = "test4" //自动判断变量的类型,为"test4" String

三、省略var,使用:=直接赋值(左侧变量不能为声明过的,且只能在函数体内使用):

1
test5 := "test5"

实例程序:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

var test1 string //没赋值,初始值为""空字符串
var test2 int //没赋值,初始值为0
var test3 string = "test2" //赋值了,为test2
var test4 = "test4" //自动判断变量的类型

func main(){
test5 := "test5"
fmt.Println(test1,test2,test3) //打印第一种情况
fmt.Println(test4) //打印第二种情况
fmt.Println(test5) //打印第三种情况
}

得到程序的输出:

1
2
3
0 test2 //打印第一种情况
test4 //打印第二种情况
test5 //打印第三种情况

(2)多变量的声明:

声明规则:

1
2
3
4
5
6
7
8
9
10
11
12
13
//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3 //和python很像,不需要显示声明类型,自动推断

vname1, vname2, vname3 := v1, v2, v3 //出现在:=左侧的变量不应该是已经被声明过的,否则会导致编译错误

// 这种因式分解关键字的写法一般用于声明全局变量
var (
vname1 v_type1
vname2 v_type2
)

实例代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

var x, y int

var (
a int
b bool
)
var c, d int = 1, 2
var e, f = 123, "hello world"

func main(){
g, h := 456, "hello go"
println(x,y,a,b,c,d,e,f,g,h)
}

得到程序的输出:

1
0 0 0 false 1 2 123 hello world 456 hello go

(3)值的类型和引用类型

  1. 所有像 int、float、bool 和 string 这些基本类型都属于值类型,使用这些类型的变量直接指向存在内存中的值:
  2. 当使用等号 = 将一个变量的值赋值给另一个变量时,如:j = i,实际上是在内存中将 i 的进行了拷贝
  3. 可以通过 &i 来获取变量 i 的内存地址。值类型的变量的值存储在栈中。内存地址会根据机器的不同而有所不同,甚至相同的程序在不同的机器上执行后也会有不同的内存地址。因为每台机器可能有不同的存储器布局,并且位置分配也可能不同。

    1. 一个引用类型的变量 r1 存储的是 r1 的值所在的内存地址(数字),或内存地址中第一个字所在的位置。 如图:

    2. 这个内存地址称为指针,实际上是存在另外的某一个字里面

    3. 同一个引用类型的指针指向的多个字可以是在连续的内存地址中(内存布局是连续的),这也是计算效率最高的一种存储形式;也可以将这些字分散存放在内存中,每个字都指示了下一个字所在的内存地址

    4. 当赋值语句r2 = r1,只是复制引用地址:

      实例代码:

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      package main

      var v1 int = 1
      var v2 int = 2
      var v3, v4 = v1, v2 //v3,v4为v1 v2的拷贝
      var v5, v6 = &v1, &v2 //v5,v6为v1 v2的引用

      func main(){
      println(v1," ",v2)//打印原值v1 v2
      println(v3," ",v4) //打印拷贝的v1 v2
      println(v5," ",v6) //打印v1 v2的引用
      println(*v5," ",*v6) //打印v1 v2的解引用(引用的地址的值)
      v2 = 3 // 修改v2为3
      println(*v5," ",*v6) //打印v1 v2的解引用(引用的地址的值)
      println(v3," ",v4) //打印拷贝的v1 v2
      }

      程序输出:

      1
      2
      3
      4
      5
      6
      1   2 //打印原值v1 v2
      1 2 //打印拷贝的v1 v2
      0x49d138 0x49d140 //打印v1 v2的引用
      1 2 //打印v1 v2的解引用(引用的地址的值)
      1 3 //打印v1 v2的解引用(引用的地址的值)(修改v2为3后) 发现变化了
      1 2 //打印拷贝的v1 v2,因为不是引用,因此不会变化
生活再忙,也不要忘记生活原本简单的样子
0%