四、Go语言数据类型
在 Go 编程语言中，数据类型用于声明函数和变量。
数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。
Go 语言按类别有以下几种数据类型：
| 序号 | 类型和描述 |
|---|---|
| 1 | 布尔型 布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。 |
| 2 | 数字类型 整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。 |
| 3 | 字符串类型: 字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。 |
| 4 | 派生类型: 包括： * (a) 指针类型（Pointer） * (b) 数组类型 * (c) 结构化类型(struct) * (d) Channel 类型 * (e) 函数类型 * (f) 切片类型 * (g) 接口类型（interface） * (h) Map 类型 |
1.数字类型
Go 也有基于架构的类型，例如：int、uint 和 uintptr。
| 序号 | 类型和描述 |
|---|---|
| 1 | uint8 无符号 8 位整型 (0 到 255) |
| 2 | uint16 无符号 16 位整型 (0 到 65535) |
| 3 | uint32 无符号 32 位整型 (0 到 4294967295) |
| 4 | uint64 无符号 64 位整型 (0 到 18446744073709551615) |
| 5 | int8 有符号 8 位整型 (-128 到 127) |
| 6 | int16 有符号 16 位整型 (-32768 到 32767) |
| 7 | int32 有符号 32 位整型 (-2147483648 到 2147483647) |
| 8 | int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807) |
2.浮点型
| 序号 | 类型和描述 |
|---|---|
| 1 | float32 IEEE-754 32位浮点型数 |
| 2 | float64 IEEE-754 64位浮点型数 |
| 3 | complex64 32 位实数和虚数 |
| 4 | complex128 64 位实数和虚数 |
3.其他数字类型
| 序号 | 类型和描述 |
|---|---|
| 1 | byte 类似 uint8 |
| 2 | rune 类似 int32 |
| 3 | uint 32 或 64 位 |
| 4 | int 与 uint 一样大小 |
| 5 | uintptr 无符号整型，用于存放一个指针 |
五、Go语言变量
变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。
变量可以通过变量名访问。
Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。
声明变量的一般形式是使用 var 关键字：
Go
var identifier type可以一次声明多个变量：
Go
var identifier1, identifier2 type
Go
//实例
package main
import "fmt"
func main() {
var a string = "Runoob"
fmt.Println(a)
var b, c int = 1, 2
fmt.Println(b, c)
}运行结果
1.变量声明
第一种，指定变量类型，如果没有初始化，则变量默认为零值。
Go
var v_name v_type
v_name = value零值就是变量没有做初始化时系统默认设置的值。
Go
package main
import "fmt"
func main() {
// 声明一个变量并初始化
var a = "RUNOOB"
fmt.Println(a)
// 没有初始化就为零值
var b int
fmt.Println(b)
// bool 零值为 false
var c bool
fmt.Println(c)
}
-
数值类型（包括complex64/128）为 0
-
布尔类型为 false
-
字符串为 ""（空字符串）
-
以下几种类型为 nil：
Go
var a *int
var a []int
var a map[string] int
var a chan int
var a func(string) int
var a error // error 是接口
Go
//实例
package main
import "fmt"
func main() {
var i int
var f float64
var b bool
var s string
fmt.Printf("%v %v %v %q\n", i, f, b, s)
}
第二种，根据值自行判定变量类型。
Go
var v_name = value
Go
//实例
package main
import "fmt"
func main() {
var d = true
fmt.Println(d)
}
第三种，如果变量已经使用 var 声明过了，再使用 := 声明变量，就产生编译错误，格式：
Go
v_name := value例如：
Go
var intVal int
intVal :=1 // 这时候会产生编译错误，因为 intVal 已经声明，不需要重新声明直接使用下面的语句即可：
Go
intVal := 1 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句intVal := 1 相等于：⬇️
Go
var intVal int
intVal =1 可以将 var f string = "Runoob" 简写为 f := "Runoob"：
Go
package main
import "fmt"
func main() {
f := "Runoob" // var f string = "Runoob"
fmt.Println(f)
}
2.多变量声明
Go
//类型相同多个变量, 非全局变量
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
)
Go
//实例
package main
import "fmt"
var x, y int
var ( // 这种因式分解关键字的写法一般用于声明全局变量
a int
b bool
)
var c, d int = 1, 2
var e, f = 123, "hello"
//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"
func main(){
g, h := 123, "hello"
fmt.Println(x, y, a, b, c, d, e, f, g, h)
}
3.值类型和引用类型
所有像 int、float、bool 和 string 这些基本类型都属于值类型，使用这些类型的变量直接指向存在内存中的值：
（int）i -----> 7
当使用等号 = 将一个变量的值赋值给另一个变量时，如：j = i，实际上是在内存中将 i 的值进行了拷贝：
（int）i -----> 7
（int）j -----> 7
你可以通过 &i 来获取变量 i 的内存地址，例如：0xf840000040（每次的地址都可能不一样）。
值类型变量通常存储在栈中，尤其是当它们是局部变量时。当值类型变量的值需要在函数作用域之外使用时，Go 会将其分配到堆内存中。
内存地址会根据机器的不同而有所不同，甚至相同的程序在不同的机器上执行后也会有不同的内存地址。因为每台机器可能有不同的存储器布局，并且位置分配也可能不同。
更复杂的数据通常会需要使用多个字，这些数据一般使用引用类型保存。
一个引用类型的变量 r1 存储的是 r1 的值所在的内存地址（数字），或内存地址中第一个字所在的位置。
这个内存地址称之为指针，这个指针实际上也被存在另外的某一个值中。
同一个引用类型的指针指向的多个字可以是在连续的内存地址中（内存布局是连续的），这也是计算效率最高的一种存储形式；也可以将这些字分散存放在内存中，每个字都指示了下一个字所在的内存地址。
当使用赋值语句 r2 = r1 时，只有引用（地址）被复制。
如果 r1 的值被改变了，那么这个值的所有引用都会指向被修改后的内容，在这个例子中，r2 也会受到影响。
4.简短形式，使用 := 赋值操作符
在变量的初始化时省略变量的类型而由系统自动推断，声明语句写上 var 关键字其实是显得有些多余了，因此可以将它们简写为 a := 50 或 b := false。
a 和 b 的类型（int 和 bool）将由编译器自动推断。
这是使用变量的首选形式，但是它只能被用在函数体内，而不可以用于全局变量的声明与赋值。使用操作符 := 可以高效地创建一个新的变量，称之为初始化声明。
⚠️注意事项
如果在相同的代码块中，我们不可以再次对于相同名称的变量使用初始化声明，例如：a := 20 就是不被允许的，编译器会提示错误 no new variables on left side of :=，但是 a = 20 是可以的，因为这是给相同的变量赋予一个新的值。
如果你在定义变量 a 之前使用它，则会得到编译错误 undefined: a。
如果你声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误，例如下面这个例子当中的变量 a：
Go
package main
import "fmt"
func main() {
var a string = "abc"
fmt.Println("hello, world")
}尝试编译这段代码将得到错误 a declared but not used。
此外，单纯地给 a 赋值也是不够的，这个值必须被使用，所以使用
Go
fmt.Println("hello, world", a)会移除错误。
但是全局变量是允许声明但不使用的。 同一类型的多个变量可以声明在同一行，如：
Go
var a, b, c int多变量可以在同一行进行赋值，如：
Go
var a, b int
var c string
a, b, c = 5, 7, "abc"上面这行假设了变量 a，b 和 c 都已经被声明，否则的话应该这样使用：
Go
a, b, c := 5, 7, "abc"右边的这些值以相同的顺序赋值给左边的变量，所以 a 的值是 5， b 的值是 7，c 的值是 "abc"。
这被称为 并行 或 同时 赋值。
如果你想要交换两个变量的值，则可以简单地使用 a, b = b, a，两个变量的类型必须是相同。
空白标识符 _ 也被用于抛弃值，如值 5 在：_, b = 5, 7 中被抛弃。
_ 实际上是一个只写变量，你不能得到它的值。这样做是因为 Go 语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值。
并行赋值也被用于当一个函数返回多个返回值时，比如这里的 val 和错误 err 是通过调用 Func1 函数同时得到：val, err = Func1(var1)。
关于第4点的笔记（个人理解）
1.不能对同一变量重复 "初始化声明"（
:=vs=）规则核心：
:=是 声明 + 赋值 一体的语法（只能用在函数内，局部变量）；=是 单纯赋值（变量必须已经声明过）；- 同一代码块中，变量只能被 "声明" 一次，但可以 "赋值" 无数次。
Gofunc main() { // 正确：第一次声明+赋值（初始化） a := 10 // 错误：同一代码块中重复声明（:= 试图再次声明a） // a := 20 // 编译器报错：no new variables on left side of := // 正确：单纯赋值（a已声明，仅更新值） a = 20 fmt.Println(a) // 输出 20 }
:=的本质是 "声明新变量并赋值"，编译器会检查左边的变量是否已存在：如果所有变量都已声明过，就会报错（没有新变量需要声明）；如果左边有部分新变量，部分已存在，是允许的（仅声明新变量）：
Gofunc main() { a := 10 // 声明a a, b := 20, 30 // 允许：a已声明（仅赋值），b是新变量（声明+赋值） fmt.Println(a, b) // 输出 20 30 }2.使用变量前必须先声明
规则核心：
变量的 "声明" 是告诉编译器 "这个变量存在、是什么类型"，未声明的变量相当于 "不存在"，无法使用。
错误例子：
Gofunc main() { // 错误：使用a之前未声明 fmt.Println(a) // 编译器报错：undefined: a }正确例子：
Gofunc main() { var a int // 先声明 a = 10 // 再赋值 fmt.Println(a) // 正确：a已声明+赋值，可使用 }3.局部变量声明后必须使用，全局变量可以 "声明不使用"
规则核心：
- 局部变量（函数内声明）：声明后必须被 "读取 / 使用"（仅赋值不算使用）；
- 全局变量（函数外声明）：允许声明后不使用（Go 不限制全局变量的 "无用"，因为可能被其他包引用）。
例子对比：
Go// 全局变量：声明不使用，允许（无报错） var globalA string = "abc" func main() { // 局部变量：声明后未使用，错误 var localA string = "abc" fmt.Println("hello") // 编译器报错：localA declared but not used // 正确：局部变量被使用（打印时用到了localA） fmt.Println("hello", localA) // 无报错 }原因：
Go 语言的编译器会强制 "消除无用代码"------ 局部变量如果只声明不使用，属于无效代码，会被编译器拦截（避免开发者写冗余代码）；而全局变量可能被其他包导入使用，编译器无法提前判断，所以允许 "声明不使用"。
4.同一类型的多变量可合并声明
规则核心：
多个同类型变量可以写在同一行，简化代码（相当于批量声明）。
Gofunc main() { // 同一类型（int）的3个变量合并声明 var a, b, c int a = 1 b = 2 c = 3 fmt.Println(a, b, c) // 输出 1 2 3 // 声明时直接赋值（同类型） var x, y, z int = 10, 20, 30 fmt.Println(x, y, z) // 输出 10 20 30 }5.多变量 "并行赋值"（同时赋值）
规则核心：
- 多个变量可以在同一行同时赋值（不管是否已声明）；
- 已声明变量用
=，未声明变量用:=；- 右边的值按 "顺序对应" 赋值给左边变量（左边变量数 = 右边值数）。
Gofunc main() { // 情况1：变量已声明，用 = 并行赋值 var a, b int var c string a, b, c = 5, 7, "abc" // 顺序对应：a=5，b=7，c="abc" fmt.Println(a, b, c) // 输出 5 7 abc // 情况2：变量未声明，用 := 并行声明+赋值 x, y, z := 10, 20, "def" fmt.Println(x, y, z) // 输出 10 20 def }6.并行赋值的经典用法：变量交换
规则核心：
利用并行赋值，可以不借助临时变量，直接交换两个变量的值（要求两个变量类型相同）。
Gofunc main() { a, b := 10, 20 fmt.Println("交换前：", a, b) // 输出 交换前：10 20 // 交换：a 和 b 的值直接互换（无需临时变量） a, b = b, a fmt.Println("交换后：", a, b) // 输出 交换后：20 10 }原理：
Go 会先计算右边所有值（
b=20，a=10），再一次性赋值给左边变量（a=20，b=10），避免中间值被覆盖。7.空白标识符
_：抛弃不需要的值规则核心：
_是 Go 的 "空白标识符"，本质是一个 "只写变量"（能接收值，但不能读取它的值）；- 用途：抛弃不需要的返回值 / 赋值（因为 Go 要求 "所有声明的变量必须使用"，用
_接收就不算 "未使用"）。
Go//例1:抛弃赋值中的某个值 func main() { // 只想获取第二个值7，抛弃第一个值5 _, b := 5, 7 fmt.Println(b) // 输出 7 // fmt.Println(_) // 错误：不能读取 _ 的值（_ 是只写变量） }
Go//例2:抛弃函数的多余返回值 //Go 很多函数会返回多个值（如 err 错误信息），如果不需要某个返回值，用 _ 抛弃： // 模拟一个返回"结果+错误"的函数 func divide(a, b int) (int, error) { if b == 0 { return 0, fmt.Errorf("除数不能为0") } return a / b, nil } func main() { // 只想获取结果，抛弃错误（假设确定b不为0） res, _ := divide(10, 2) fmt.Println(res) // 输出 5 // 如果不用 _：err 变量未使用，会报错 // res, err := divide(10, 2) // fmt.Println(res) // 报错：err declared but not used }总结：核心避坑点
:=是 "声明 + 赋值"，同一代码块不能重复声明同一变量；=是单纯赋值，需变量已声明；- 局部变量 "声明必使用"（仅赋值不算使用），全局变量无此限制；
- 并行赋值可简化代码、实现无临时变量交换，左右值数量必须匹配；
_用于抛弃无用值，解决 "声明未使用" 的报错，且不能读取。这些规则本质是 Go 语言 "简洁、高效、无冗余" 的设计体现，记住 "声明一次、使用一次、赋值随意" 的核心逻辑，就能避免大部分变量相关的编译错误。