【Go笔记】第 3 章 Golang 变量

Suriski 9/19/2022 韩顺平尚硅谷golang笔记

【尚硅谷】Golang入门到实战教程丨一套精通GO语言 (opens new window)笔记，可在Bilibili同步观看
尚硅谷-视频观看地址 (opens new window)

# 3.1 为什么需要变量

# 3.1.1一个程序就是一个世界

# 3.1.2变量是程序的基本组成单位

不论是使用哪种高级程序语言编写程序,变量都是其程序的基本组成单位，比如一个示意图：

比如上图的 sum,sub 都是变量。

# 3.2 变量的介绍

# 3.2.1变量的概念

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

# 3.2.2变量的使用步骤

声明变量(也叫:定义变量)
非变量赋值
使用变量

# 3.3 变量快速入门案例

看一个案例:

package main
import "fmt"

func main(){
	//定义变量/声明变量
	var i int
	//给i 赋值
	i = 10
	//使用变量
	fmt.Println("i=",i)
}

//输出
//i = 10

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

# 3.4 变量使用注意事项

变量表示内存中的一个存储区域
该区域有自己的名称（变量名）和类型（数据类型）示意图：
Golang 变量使用的三种方式

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

第二种：根据值自行判定变量类型(类型推导)

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

多变量声明在编程中，有时我们需要一次性声明多个变量，Golang 也提供这样的语法举例说明:

如何一次性声明多个全局变量【在 go 中函数外部定义变量就是全局变量】：

该区域的数据值可以在同一类型范围内不断变化(重点)

变量在同一个作用域(在一个函数或者在代码块)内不能重名

变量= 变量名+ 值+ 数据类型，这一点请大家注意，变量的三要素
Golang 的变量如果没有赋初值，编译器会使用默认值, 比如 int 默认值 0 string 默认值为空串，小数默认为 0

# 3.5 变量的声明，初始化和赋值

声明变量基本语法：var 变量名数据类型 var a int 这就是声明了一个变量，变量名是a var num1 float32 这也是声明了一个变量，表示一个单精度类型的小数，变量名是num1

初始化变量在声明变量的时候，就给值 var a int = 45,这就是初始化变量 a 使用细节，如果声明时就直接赋值，可省略数据类型 var b = 400

给变量赋值比如你先声明了变量：var num int //默认0 然后，再给值num = 780 这就是给变量赋值

# 3.6 程序中 +号的使用

当左右两边都是数值型时，则做加法运算
当左右两边都是字符串，则做字符串拼接

# 3.7 数据类型的基本介绍

# 3.8 整数类型

# 3.8.1基本介绍

简单的说，就是用于存放整数值的，比如 0, -1, 2345 等等。

# 3.8.2案例演示

# 3.8.3整数的各个类型

int 的无符号的类型：

int 的其它类型的说明:

# 3.8.4整型的使用细节

Golang 各整数类型分：有符号和无符号，int uint 的大小和系统有关。
Golang 的整型默认声明为 int 型

3) 如何在程序查看某个变量的字节大小和数据类型（使用较多）

4) Golang 程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的数据类型。【如：年龄】

5) bit: 计算机中的最小存储单位。byte:计算机中基本存储单元。[二进制再详细说] 1byte = 8 bit

# 3.9 小数类型/浮点型

# 3.9.1基本介绍

小数类型就是用于存放小数的，比如 1.2 0.23 -1.911

# 3.9.2案例演示

package main  
  
import "fmt"  
  
func main() {  
   var price float32 = 89.2  
   fmt.Println("price=", price)  
}

1
2
3
4
5
6
7
8

# 3.9.3小数类型分类

对上图的说明:

关于浮点数在机器中存放形式的简单说明,浮点数=符号位+指数位+尾数位说明：浮点数都是有符号的.

package main  
  
import "fmt"  
  
//演示Golang中小数类型的使用  
func main() {  
   var price float32 = 89.12  
   fmt.Println("price=", price)  
   var num1 float32 = -0.00089  
   var num2 float64 = -7809656.09  
   fmt.Println("num1=", num1, "num2=", num2)  
}

1
2
3
4
5
6
7
8
9
10
11
12

尾数部分可能丢失，造成精度损失。 -123.0000901

package main  
  
import "fmt"  
  
//演示Golang中小数类型的使用  
func main() {  
   var num3 float32 = -123.0000901  
   var num4 float64 = -123.0000901  
   fmt.Println("num3=", num3, "num4=", num4)  
}
//输出
//num3= -123.00009 num4= -123.0000901

1
2
3
4
5
6
7
8
9
10
11
12

说明：float64 的精度比 float32 的要准确. 说明：如果我们要保存一个精度高的数，则应该选用 float64

浮点型的存储分为三部分：符号位+指数位+尾数位在存储过程中，精度会有丢失

# 3.9.4浮点型使用细节

Golang 浮点类型有固定的范围和字段长度，不受具体 OS(操作系统)的影响。
Golang 的浮点型默认声明为 float64 类型。

//Golang 的浮点型默认声明float64类型  
var num5 = 1.1  
fmt.Printf("num5的数据类型是%T\n", num5)

1
2
3

浮点型常量有两种表示形式十进制数形式：如：5.12 .512 (必须有小数点）科学计数法形式:如：5.1234e2 = 5.12 * 10 的 2 次方 5.12E-2 = 5.12/10 的 2 次方

//十进制数形式：如：5.12    .512（必须有小数点）  
num6 := 5.12  
num7 := .123  
fmt.Println("num6=", num6, "num7=", num7)  
  
//科学计数法形式  
num8 := 5.1234e2      //? 5.1234 * 10 的2次方  
num9 := 5.1234e2      //? 5.1234 * 10 的2次方 shift+alt+向下的箭头  
num10 := 5.1234e2 - 2 //? 5.1234 / 10 的2次方 0.051234

1
2
3
4
5
6
7
8
9

通常情况下，应该使用 float64 ，因为它比 float32 更精确。开发中，推荐使用 float64

# 3.10 字符类型

# 3.10.1 基本介绍

Golang 中没有专门的字符类型，如果要存储单个字符(字母)，一般使用 byte 来保存。字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。也就是说对于传统的字符串是由字符组成的，而 Go 的字符串不同，它是由字节组成的。

# 3.10.2 案例演示

package main  
  
import "fmt"  
  
func main() {  
   var c1 byte = 'a'  
   var c2 byte = '0' //字符的0  
  
   //当我么你直接输出byte值，就是输出了的对于的字符的码值  
   //'a' ==>  
   fmt.Println("c1=", c1)  
   fmt.Println("c2=", c2)  
   //如果我们希望输出对于字符，需要使用格式化输出  
   fmt.Printf("c1=%c  c2=%c", c1, c2)  
  
   //var c3 byte = '北' //overflow 溢出  
   var c3 int = '北' // overflow 溢出  
   fmt.Printf("c3=%c  c3对应码值=%d", c3, c3)  
}

//输出
//c1= 97
//c2= 48                           
//c1=a  c2=0c3=北  c3对应码值=21271

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

对上面代码说明

如果我们保存的字符在 ASCII 表的,比如[0-1, a-z,A-Z..]直接可以保存到 byte
如果我们保存的字符对应码值大于 255,这时我们可以考虑使用 int 类型保存
如果我们需要安装字符的方式输出，这时我们需要格式化输出，即 fmt.Printf(“%c”, c1)..

# 3.10.3 字符类型使用细节

字符常量是用单引号('')括起来的单个字符。例如：var c1 byte = 'a' var c2 int = '中' var c3 byte = '9'
Go 中允许使用转义字符 '\’来将其后的字符转变为特殊字符型常量。例如：var c3 char = ‘\n’ // \n表示换行符
Go 语言的字符使用 UTF-8 编码，如果想查询字符对应的 utf8 码值 (opens new window) 英文字母-1 个字节汉字-3 个字节
在 Go 中，字符的本质是一个整数，直接输出时，是该字符对应的 UTF-8 编码的码值。
可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的 unicode 字符

//可以直接个某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的unicode字符  
var c4 int = 22269 //22269 -> '国' 120 > 'x'  
fmt.Printf("c4=%c\n", c4)

1
2
3

字符类型是可以进行运算的，相当于一个整数，因为它都对应有 Unicode 码.

  
//字符类型是可以进行运算，相当于一个整数，运输时是按照码值运行  
var n1 = 10 + 'a' //10 + 97 = 107  
fmt.Println("n1=", n1)

1
2
3
4

# 3.10.4 字符类型本质探讨

字符型存储到计算机中，需要将字符对应的码值（整数）找出来存储：字符--->对应码值---->二进制-->存储读取：二进制----> 码值 ----> 字符 --> 读取
字符和码值的对应关系是通过字符编码表决定的(是规定好)
Go 语言的编码都统一成了 utf-8。非常的方便，很统一，再也没有编码乱码的困扰了

# 3.11 布尔类型

# 3.11.1 基本介绍

布尔类型也叫 bool 类型，bool 类型数据只允许取值 true 和 false
bool 类型占 1 个字节。
bool 类型适于逻辑运算，一般用于程序流程控制[注：这个后面会详细介绍]：

if 条件控制语句；
for 循环控制语句

# 3.11.2 案例演示

func main() {  
  
   var b = false  
   fmt.Println("b=", b)  
   //注意事项  
  
   //1.boo1类型占用存储空间是1个字节  
  
   fmt.Println("b的占用空间=", unsafe.Sizeof(b))  
  
   //2.bool类型只能取true或者fa1se  
}

1
2
3
4
5
6
7
8
9
10
11
12

# 3.12 string 类型

# 3.12.1 基本介绍

字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本

# 3.12.2 案例演示

func main() {  
   //string的基本使用  
   var address string = "北京长城 110 hello word"   fmt.Println(address)  
}

1
2
3
4

# 3.12.3 string 使用注意事项和细节

Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本，这样 Golang 统一使用 UTF-8 编码,中文乱码问题不会再困扰程序员。
字符串一旦赋值了，字符串就不能修改了：在 Go 中字符串是不可变的。

//字符串一旦赋值，字符串就不能修改了；在Go中字符串是不可变的  
var str = "hello"  
// str[0] = 'a'//(错误)这里就不能去修改str 的内容，即go中的字符串是不可变的

1
2
3

字符串的两种表示形式 (1) 双引号, 会识别转义字符 (2) 反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果【案例演示】

func main() {  
   str2 := "abc\nabc"  
   fmt.Println(str2)  
  
   //使用反引号``  
   str3 := `  
   //string的基本使用  
   var address string = "北京长城 110 hello word"   fmt.Println(address)  
   //字符串一旦赋值，字符串就不能修改了；在Go中字符串是不可变的  
   var str = "hello"   str[0] = 'a' //这里就不能去修改str 的内容，即go中的字符串是不可变的  
   `   fmt.Println(str3)  
}

1
2
3
4
5
6
7
8
9
10
11
12

字符串拼接方式

var str4 = "hello" + "world"  
str4 += "hahah !"  
  
fmt.Println(str4)

1
2
3
4

当一行字符串太长时，需要使用到多行字符串，可以如下处理

//当一个拼接的操作很长时，怎么办？可以分行写，但是阿注意，需要将+保留在上一行  
var str5 = "hello" + "world" + "haha!" + "haha!" + "haha!" + "haha!" +  
   "haha!" + "haha!" + "haha!" + "haha!" + "haha!" +  
   "haha!"  
  
	fmt.Println(str5)

1
2
3
4
5
6

# 3.13 基本数据类型的默认值

# 3.13.1 基本介绍

在 go 中，数据类型都有一个默认值，当程序员没有赋值时，就会保留默认值，在 go 中，默认值又叫零值。

# 3.13.2 基本数据类型的默认值如下

数据类型	默认值
整形	0
浮点型	0
字符串	""
布尔类型	false

案例：

func main() {  
   var a int          //0  
   var b float32      //0  
   var c float64      //0  
   var isMarried bool //fasle  
   var name string    // ""  
  
   //这里%v 表示按照变量的值输出  
   fmt.Printf("a=%d\nb=%v\nc=%v\nisMarried=%v\nname=%v\n", a, b, c, isMarried, name)  
}
//输出
/**
a=0
b=0
c=0
isMarried=false
name=
**/

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

# 3.14 基本数据类型的相互转换

# 3.14.1 基本介绍

Golang 和 java / c 不同，Go 在不同类型的变量之间赋值时需要显式转换。也就是说 Golang 中数据类型不能自动转换。

# 3.14.2 基本语法

表达式 T(v) 将值 v 转换为类型 T T: 就是数据类型，比如 int32，int64，float32 等等 v: 就是需要转换的变量

# 3.14.3 案例演示

func main() {  
   var i int32 = 100  
   //希望将 i  => float   var n1 float32 = float32(i)  
   var n2 int8 = int8(i)  
   var n3 int64 = int64(i) //低精度 -> 高精度  
  
   fmt.Printf("i=%v\n n1=%v\n n2=%v\n n3=%v\n ", i, n1, n2, n3)  
}

1
2
3
4
5
6
7
8

# 3.14.4 基本数据类型相互转换的注意事项

Go 中，数据类型的转换可以是从表示范围小-->表示范围大，也可以范围大--->范围小
被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化！

func main() {  
   var i int32 = 100  
   //希望将 i  => float   var n1 float32 = float32(i)  
   var n2 int8 = int8(i)  
   var n3 int64 = int64(i) //低精度 -> 高精度  
  
   fmt.Printf("i=%v\n n1=%v\n n2=%v\n n3=%v\n ", i, n1, n2, n3)  
  
   //被转换的是变量存储的数据（既值），变量本身的数据类型并没有变化  
   fmt.Printf("i type is %T\n", i) //int32  
}

1
2
3
4
5
6
7
8
9
10
11

在转换中，比如将 int64 转成 int8 【-128---127】，编译时不会报错，只是转换的结果是按溢出处理，和我们希望的结果不一样。因此在转换时，需要考虑范围.

var num1 int64 = 999999  
var num2 int8 = int8(num1)  
fmt.Println("num2=", num2)

1
2
3

# 3.14.5 课堂练习

练习一：

func main() {  
   var n1 int32 = 12  
   var n2 int64  
   var n3 int8  
  
   n2 = int64(n1) + 20  
   n3 = int8(n1) + 20  
  
   fmt.Println("n2=", n2, "n3=", n3)  
}

1
2
3
4
5
6
7
8
9
10

# 3.15 基本数据类型和 string 的转换

# 3.15.1 基本介绍

在程序开发中，我们经常将基本数据类型转成 string,或者将 string 转成基本数据类型。

# 3.15.2 基本类型转 string 类型

方式 1：fmt.Sprintf("%参数", 表达式) 【个人习惯这个，灵活】函数的介绍：

参数需要和表达式的数据类型相匹配 fmt.Sprintf().. 会返回转换后的字符串

案例演示：

package main  
  
import "fmt"  
  
func main() {  
  
   var num1 int = 99  
   var num2 float64 = 23.456  
   var b bool = true  
   var myChar byte = 'h'  
   var str string //空的str  
  
   //使用第一种方式来转换fmt.Sprintf方法  
  
   str = fmt.Sprintf("%d", num1)  
   fmt.Printf("str type %T str=%q\n", str, str)  
  
   str = fmt.Sprintf("%f", num2)  
   fmt.Printf("str type %T str=%q\n", str, str)  
  
   str = fmt.Sprintf("%t", b)  
   fmt.Printf("str type %T str=%q\n", str, str)  
  
   str = fmt.Sprintf("%c", myChar)  
   fmt.Printf("str type %T str=%q\n", str, str)  
}

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

案例说明:

//第二种方法strconv 函数  
var num3 int = 99  
var num4 float64 = 23.456  
var b2 bool = true  
var num5 int64 = 4567  
  
str = strconv.FormatInt(int64(num3), 10)  
fmt.Printf("str type %T str=%q\n", str, str)  
  
//stronv.FormatFloat(num4,'f',10,64)  
//说明：'f' 格式 10 ：表示小数位保留10位，64 ：表示这个小数是float64  
  
str = strconv.FormatFloat(num4, 'f', 10, 64)  
fmt.Printf("str type %T str=%q\n", str, str)  
  
str = strconv.FormatBool(b2)  
fmt.Printf("str type %T str=%q\n", str, str)  
  
str = strconv.Itoa(int(num5))  
fmt.Printf("str type %T str=%q\n", str, str)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 3.15.3 string 类型转基本数据类型

🏷 使用时 strconv 包的函数

# 3.15.4 string 转基本数据类型的注意事项

在将 String 类型转成基本数据类型时，要确保 String 类型能够转成有效的数据，比如我们可以把 "123" , 转成一个整数，但是不能把 "hello" 转成一个整数，如果这样做，Golang 直接将其转成 0 ，其它类型也是一样的道理. float => 0 bool => false

案例说明：

func main() {  
   var str4 string = "hello"  
   var n3 int64 = 11  
   n3, _ = strconv.ParseInt(str4, 10, 64)  
   fmt.Printf("n3 type %T n3=%v\n", n3, n3)  
}

1
2
3
4
5
6

# 3.16 指针

# 3.16.1 基本介绍

基本数据类型，变量存的就是值，也叫值类型
获取变量的地址，用&，比如： var num int, 获取 num 的地址：&num 分析一下基本数据类型在内存的布局.

3) 指针类型，指针变量存的是一个地址，这个地址指向的空间存的才是值比如：var ptr *int = &num 举例说明：指针在内存的布局.

4) 获取指针类型所指向的值，使用：*，比如：var ptr *int, 使用*ptr 获取 ptr 指向的值

//基本数据类型在内存分部  
var i int = 10  
//i的地址是什么？&i  
fmt.Println("i的地址=", &i)  
  
//下面的var ptr *int = &i  
//1. ptr 是一个指针变量  
//2. ptr 的类型 *int//3. ptr 本身的值&i  
var ptr *int = &i  
fmt.Printf("ptr = %v\n", ptr)  
fmt.Printf("ptr 的指针= %v\n", &ptr)  
fmt.Printf("ptr 指向的值= %v\n", *ptr)

1
2
3
4
5
6
7
8
9
10
11
12

一个案例再说明

# 3.16.2 案例演示

写一个程序，获取一个 int 变量 num 的地址，并显示到终端
将 num 的地址赋给指针 ptr , 并通过 ptr 去修改 num 的值.

# 3.16.3 指针的课堂练习

# 3.16.4 指针的使用细节

值类型，都有对应的指针类型，形式为 * 数据类型，比如 int 的对应的指针就是 *int, float32对应的指针类型就是 *float32, 依次类推。
值类型包括：基本数据类型int 系列, float 系列, bool, string 、数组和结构体 struct

# 3.17 值类型和引用类型

# 3.17.1 值类型和引用类型的说明

值类型：基本数据类型 int 系列, float 系列, bool, string 、数组和结构体 struct
引用类型：指针、slice 切片、map、管道 chan、interface 等都是引用类型

# 3.17.2 值类型和引用类型的使用特点

值类型：变量直接存储值，内存通常在栈中分配示意图：

引用类型：变量存储的是一个地址，这个地址对应的空间才真正存储数据(值)，内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由 GC 来回收示意图：

内存的栈区和堆区示意图

# 3.18 标识符的命名规范

# 3.18.1 标识符概念

Golang 对各种变量、方法、函数等命名时使用的字符序列称为标识符
凡是自己可以起名字的地方都叫标识符 3.18.2 标识符的命名规则
由 26 个英文字母大小写，0-9 ，_ 组成
数字不可以开头。var num int //ok var 3num int //error
Golang 中严格区分大小写。 var num int var Num int 说明：在 golang 中，num 和 Num 是两个不同的变量
标识符不能包含空格。

下划线_本身在 Go 中是一个特殊的标识符，称为空标识符。可以代表任何其它的标识符，但是它对应的值会被忽略(比如：忽略某个返回值)。所以仅能被作为占位符使用，不能作为标识符使用

不能以系统保留关键字作为标识符（一共有 25 个），比如 break，if 等等...

# 3.18.3 标识符的案例

	hello // ok
	hello12 //ok
	1hello // error ,不能以数字开头
	h-b // error ,不能使用 -
	x h // error, 不能含有空格
	h_4 // ok
	_ab // ok
	int // ok , 我们要求大家不要这样使用
	float32 // ok , 我们要求大家不要这样使用
	_ // error
	Abc // ok

1
2
3
4
5
6
7
8
9
10
11

# 3.18.4 标识符命名注意事项

包名：保持 package 的名字和目录保持一致，尽量采取有意义的包名，简短，有意义，不要和标准库不要冲突 fmt
变量名、函数名、常量名：采用驼峰法举例：

var stuName string = “tom” 形式: xxxYyyyyZzzz ...
var goodPrice float32 = 1234.5`

1
2

如果变量名、函数名、常量名首字母大写，则可以被其他的包访问；如果首字母小写，则只能在本包中使用 ( 注：可以简单的理解成，首字母大写是公开的，首字母小写是私有的) ,在 golang 没有public , private 等关键字。

# 3.19 系统保留关键字

# 3.20 系统的预定义标识符

【Go笔记】第 2 章 Golang 的概述【Go笔记】第 4 章运算符

Suriski's Blog