yyz notes
YiZhang-You
2023-05-21
目录

变量

# 1. 变量的声明、赋值和使用 var

# 变量声明

变量表示没有固定值且可改变的数。但从计算机系统实现角度来看，变量是一段或多段用来存储数据的内存。

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

var name type
1

其中，var 是声明变量的关键字，name 是变量名，type 是变量的类型。

# 标准格式

Go语言的变量声明的标准格式为：

var 变量名 变量类型
var hp int
var hp int = 100  // 初始化值
1
2
3

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

# 批量格式

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

var (
    a int
    b string
    c []float32
    d func() bool
    e struct {
        x int
    }
)
1
2
3
4
5
6
7
8
9

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

# 简短格式（只能在函数体中使用）

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

名字 := 表达式
1

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

  • 定义变量，同时显式初始化。
  • 不能提供数据类型。
  • 只能用在函数内部。

和 var 形式声明语句一样，简短变量声明语句也可以用来声明和初始化一组变量：

i, j := 0, 1
1

下面通过一段代码来演示简短格式变量声明的基本样式。

func main() {
   x:=100
   a,s:=1, "abc"
}
1
2
3
4

因为简洁和灵活的特点，简短变量声明被广泛用于大部分的局部变量的声明和初始化。var 形式的声明语句往往是用于需要显式指定变量类型地方，或者因为变量稍后会被重新赋值而初始值无关紧要的地方。

# 变量赋值

# 普通赋值

var n6 string = "99"
fmt.Printf("普通赋值: %v\\n", n6)
1
2

# 多个变量同时赋值

到了Go语言时，内存不再是紧缺资源，而且写法可以更简单。使用 Go 的“多重赋值”特性，可以轻松完成变量交换的任务：

var a int = 100
var b int = 200
b, a = a, b
fmt.Println(a, b)
1
2
3
4

多重赋值时，变量的左值和右值按从左到右的顺序赋值。

多重赋值在Go语言的错误处理和函数返回值中会大量地使用。例如使用Go语言进行排序时就需要使用交换，代码如下

type IntSlice []int
func (p IntSlice) Len() int           { return len(p) }
func (p IntSlice) Less(i, j int) bool { return p[i] < p[j] }
func (p IntSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
1
2
3
4

# 变量使用

var n7 int = 20
var n8 = n7
fmt.Println("变量的使用: ", n8)
1
2
3

# 代码示例

package main

import "fmt"

func main() {
	// 变量的基本使用方式
	// 1. 变量的声明
	var age int
	// 2.变量的赋值
	age = 18
	// 3.变量的使用
	fmt.Println("age = ", age) // age =  18

	// 一. 变量的声明
	// 标准格式
	var hp int
	var hp1 int = 65
	fmt.Printf("标准格式: %d, %d\\n", hp, hp1)

	// 批量格式
	var (
		n1 int
		n2 string
		n3 bool
		n4 float64
	)
	fmt.Printf("批量格式：%d，%v,%t,%f\\n", n1, n2, n3, n4)

	// 简短格式（只能在函数体中使用）
	n5 := 50
	fmt.Printf("简短格式: %d\\n", n5)

	// 二. 变量赋值
	// 普通赋值
	var n6 string = "99"
	fmt.Printf("普通赋值: %v\\n", n6)
	// 多个变量同时赋值
	var a int = 100
	var b int = 200
	b, a = a, b
	fmt.Println("多个变量同时赋值: ", a, b)

	// 三. 变量的使用
	var n7 int = 20
	var n8 = n7
	fmt.Println("变量的使用: ", n8)
}

/*
	age =  18
	标准格式: 0, 65
	批量格式：0，,false,0.000000
	简短格式: 50
	普通赋值: 99
	多个变量同时赋值:  200 100
	变量的使用:  20
*/
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

# 2. 匿名变量 _

在编码过程中，可能会遇到没有名称的变量、类型或方法。虽然这不是必须的，但有时候这样做可以极大地增强代码的灵活性，这些变量被统称为匿名变量。

匿名变量的特点是一个下画线“”，“”本身就是一个特殊的标识符，被称为空白标识符。它可以像其他标识符那样用于变量的声明或赋值（任何类型都可以赋值给它），但任何赋给这个标识符的值都将被抛弃，因此这些值不能在后续的代码中使用，也不可以使用这个标识符作为变量对其它变量进行赋值或运算。使用匿名变量时，只需要在变量声明的地方使用下画线替换即可。

匿名变量不占用内存空间，不会分配内存。匿名变量与匿名变量之间也不会因为多次声明而无法使用。

# 代码示例

package main

import "fmt"

func GetData() (int, int) {
	return 100, 200
}
func main() {
	//匿名变量不占用内存空间，不会分配内存。匿名变量与匿名变量之间也不会因为多次声明而无法使用

	var _ int

	a, _ := GetData()
	_, b := GetData()
	fmt.Println(a, b)
	fmt.Println(&a) // 0xc00001e0a8 a的内存地址
	// fmt.Println(&_)  // cannot use _ as value or type
}

/*
	100 200
	0xc00001e0a8
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 3. 变量的作用域（全局、局部变量）

一个变量（常量、类型或函数）在程序中都有一定的作用范围，称之为作用域。

了解变量的作用域对我们学习Go语言来说是比较重要的，因为Go语言会在编译时检查每个变量是否使用过，一旦出现未使用的变量，就会报编译错误。如果不能理解变量的作用域，就有可能会带来一些不明所以的编译错误。

根据变量定义位置的不同，可以分为以下三个类型：

  • 函数内定义的变量称为局部变量
  • 函数外定义的变量称为全局变量
  • 函数定义中的变量称为形式参数

# 局部变量

在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，函数的参数和返回值变量都属于局部变量。

局部变量不是一直存在的，它只在定义它的函数被调用后存在，函数调用结束后这个局部变量就会被销毁。

【示例】下面的 main() 函数中使用到了局部变量 a、b、c。

package main
import (
    "fmt"
)
func main() {
    //声明局部变量 a 和 b 并赋值
    var a int = 3
    var b int = 4
    //声明局部变量 c 并计算 a 和 b 的和
    c := a + b
    fmt.Printf("a = %d, b = %d, c = %d\\n", a, b, c)
}

// a = 3, b = 4, c = 7
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 全局变量

在函数体外声明的变量称之为全局变量，全局变量只需要在一个源文件中定义，就可以在所有源文件中使用，当然，不包含这个全局变量的源文件需要使用“import”关键字引入全局变量所在的源文件之后才能使用这个全局变量。

全局变量声明必须以 var 关键字开头，如果想要在外部包中使用全局变量的首字母必须大写。

【示例】下面代码中，第 6 行定义了全局变量 c。

package main
import "fmt"
//声明全局变量
var c int
func main() {
    //声明局部变量
    var a, b int
    //初始化参数
    a = 3
    b = 4
    c = a + b
    fmt.Printf("a = %d, b = %d, c = %d\\n", a, b, c)
}

// a = 3, b = 4, c = 7
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Go语言程序中全局变量与局部变量名称可以相同，但是函数体内的局部变量会被优先考虑。

package main
import "fmt"
//声明全局变量
var a float32 = 3.14
func main() {
    //声明局部变量
    var a int = 3
    fmt.Printf("a = %d\\n", a)
}

// a = 3
1
2
3
4
5
6
7
8
9
10
11

# 形式参数

在定义函数时函数名后面括号中的变量叫做形式参数（简称形参）。形式参数只在函数调用时才会生效，函数调用结束后就会被销毁，在函数未被调用时，函数的形参并不占用实际的存储单元，也没有实际值。

形式参数会作为函数的局部变量来使用。

【示例】下面代码中第 21 行定义了形式参数 a 和 b。

package main
import (
    "fmt"
)

//全局变量 a
var a int = 13

func main() {
    //局部变量 a 和 b
    var a int = 3
    var b int = 4
    fmt.Printf("main() 函数中 a = %d\\n", a)
    fmt.Printf("main() 函数中 b = %d\\n", b)
    c := sum(a, b)
    fmt.Printf("main() 函数中 c = %d\\n", c)
}

func sum(a, b int) int {
    fmt.Printf("sum() 函数中 a = %d\\n", a)
    fmt.Printf("sum() 函数中 b = %d\\n", b)
    num := a + b
    return num
}

main() 函数中 a = 3
main() 函数中 b = 4
sum() 函数中 a = 3
sum() 函数中 b = 4
main() 函数中 c = 7
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

# 4. 注意细节点

# 1.``函数中变量的重复定义会报错（注意：全局变量与局部变量名称可以相同，但是函数体内的局部变量会被优先考虑）

# 2. 不可以在赋值的时候给与不匹配的类型

# 3. 全局变量声明必须以 var 关键字开头，如果想要在外部包中使用全局变量的首字母必须大写

# 代码示例

package main

import "fmt"

func main() {
	// 1. 函数中变量的重复定义会报错（注意：全局变量与局部变量名称可以相同，但是函数体内的局部变量会被优先考虑）
	var n1 int
	//var n1 int
	fmt.Println(n1) // 6: other declaration of n1

	// 2. 不可以在赋值的时候给与不匹配的类型
	//var n2 int = 11.1
	//fmt.Printf(n2) // cannot use n2 (variable of type int) as type string in argument to fmt.Printf

	// 3. 全局变量声明必须以 var 关键字开头，如果想要在外部包中使用全局变量的首字母必须大写
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
编辑 (opens new window)
GoLand进行Debug
常量

← 常量→

最近更新
01
配置yun源
05-24
02
linux-配置python虚拟环境
05-24
03
linux文件目录管理
05-24
更多文章>
Theme by Vdoing | Copyright © 2023-2023 yizhang | MIT License