02-变量

变量的声明

声明变量的一般形式是使用 var 关键字

单个变量声明

第一种,指定变量类型,声明后若不赋值,使用默认值0。

1
2
3
4
5
// 格式
var v_name v_type

// 示例
var a int

第二种,根据值自行判定变量类型。

1
2
3
4
5
// 格式
var v_name = value

// 示例
var a = 1

第三种,省略var, 注意 :=左侧的变量不应该是已经声明过的,否则会导致编译错误。

1
2
3
4
5
6
7
8
// 格式
v_name := value


// 示例
var a int = 10
var b = 10
c : = 10

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package main


import "fmt"


func main() {
//第一种 使用默认值
var a int
fmt.Printf("a = %d\n", a)


//第二种
var b int = 10
fmt.Printf("b = %d\n", b)


//第三种 省略后面的数据类型,自动匹配类型
var c = 20
fmt.Printf("c = %d\n", c)


//第四种 省略var关键字
d := 3.14
fmt.Printf("d = %f\n", d)
}

多变量声明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package main


import "fmt"


var x, y int
var ( //这种分解的写法,一般用于声明全局变量
a int
b bool
)


var c, d int = 1, 2
var e, f = 123, "liudanbing"


//这种不带声明格式的只能在函数体内声明
//g, h := 123, "需要在func函数体内实现"


func main() {
g, h := 123, "需要在func函数体内实现"
fmt.Println(x, y, a, b, c, d, e, f, g, h)


//不能对g变量再次做初始化声明
//g := 400


_, value := 7, 5 //实际上7的赋值被废弃,变量 _ 不具备读特性
//fmt.Println(_) //_变量的是读不出来的
fmt.Println(value) //5
}

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
package main

/*
四种变量的声明方式
*/

import (
"fmt"
)

//声明全局变量 方法一、方法二、方法三是可以的
var gA int = 100
var gB = 200

//用方法四来声明全局变量
// := 只能够用在 函数体内来声明
//gC := 200

func main() {
//方法一:声明一个变量 默认的值是0
var a int
fmt.Println("a = ", a)
fmt.Printf("type of a = %T\n", a)

//方法二:声明一个变量,初始化一个值
var b int = 100
fmt.Println("b = ", b)
fmt.Printf("type of b = %T\n", b)

var bb string = "abcd"
fmt.Printf("bb = %s, type of bb = %T\n", bb, bb)

//方法三:在初始化的时候,可以省去数据类型,通过值自动匹配当前的变量的数据类型
var c = 100
fmt.Println("c = ", c)
fmt.Printf("type of c = %T\n", c)

var cc = "abcd"
fmt.Printf("cc = %s, type of cc = %T\n", cc, cc)

//方法四:(常用的方法) 省去var关键字,直接自动匹配
e := 100
fmt.Println("e = ", e)
fmt.Printf("type of e = %T\n", e)

f := "abcd"
fmt.Println("f = ", f)
fmt.Printf("type of f = %T\n", f)

g := 3.14
fmt.Println("g = ", g)
fmt.Printf("type of g = %T\n", g)

// =====
fmt.Println("gA = ", gA, ", gB = ", gB)
//fmt.Println("gC = ", gC)

// 声明多个变量
var xx, yy int = 100, 200
fmt.Println("xx = ", xx, ", yy = ", yy)
var kk, ll = 100, "Aceld"
fmt.Println("kk = ", kk, ", ll = ", ll)

//多行的多变量声明
var (
vv int = 100
jj bool = true
)
fmt.Println("vv = ", vv, ", jj = ", jj)
}

02-变量
https://flepeng.github.io/021-Go-01-course-02-变量/
作者
Lepeng
发布于
2024年11月1日
许可协议