Golang快速入门教程(一)

目录

一、环境搭建

1.windows安装

2.linux安装 

3.开发工具

二、变量定义与输入输出

1.变量定义

2.全局变量与局部变量

3.定义多个变量

4.常量定义

5.命名规范

6.输出

7.输入 

三、基本数据类型

1.整数型

2.浮点型

3.字符型

4.字符串类型

转义字符

多行字符串

5.布尔类型

四、数组、切片、map

1.数组

 2.切片

make函数

切片面试题 

3.Map

map面试题 


一、环境搭建

官网

https://go.dev/dl/

访问不了的就访问中文网就好了

go安装包下载

https://studygolang.com/dl

安装指定版本的安装包就好了

1.windows安装

选择 xxx.windows-amd64.msi

  • 将go的对应bin目录设置为环境变量,这一步是方便可以在命令行里面直接使用go命令
  • 将go的第三方bin目录设置为环境变量,一般是在用户目录下,这一步是为了以后使用go install安装的第三方可执行文件可以直接使用

2.linux安装 

选择 xxx.linux-amd64.tar.gz

该站点比较快:All releases - The Go Programming Language

# 下载

wget https://golang.google.cn/dl/go1.22.2.linux-amd64.tar.gz

# 解压

tar -xvf go1.22.2.linux-arm64.tar.gz -C /usr/local

# 配置环境变量

echo 'export GO111MODULE=on' >> /etc/profile
echo 'export GOROOT=/usr/local/go' >> /etc/profile
echo 'export GOPATH=/home/gopath' >> /etc/profile
echo 'export PATH=$PATH:$GOROOT/bin:$GOPATH/bin' >> /etc/profile

source /etc/profile

# 创建go包安装目录

mkdir -p /home/gopath

# 设置代理

go env -w GOPROXY=https://goproxy.cn,direct

# 检查成功

go version

3.开发工具

推荐goland

二、变量定义与输入输出

1.变量定义

package main

import "fmt"

func main() {
  // 先定义,再赋值
  var name string
  name = "os_lee1"
  fmt.Println(name)
  
  // 定义加赋值
  var userName string = "os_lee1"
  fmt.Println(userName)
}

如果一个变量定义了,但是没有赋值,那么这个变量的值就是这个类型的 "零值" 

// 变量类型省略
var name = "os_lee"

// 简单声明
name := "os_lee"

2.全局变量与局部变量

定义在函数体(包括main函数)内的变量都是局部变量,定义了就必须使用
定义在外部的变量就是全局变量,可以只定义不使用 

package main

import "fmt"

// 全局变量可以不使用
var userName = "oslee_全局" 

func main() {
  // 局部变量
  var name = "oslee_局部"
  // 在函数体内定义的变量,必须要使用
  fmt.Println(name)
}

3.定义多个变量

package main

import "fmt"

func main() {
	var name1, name2, name3 string // 定义多个变量

	var a1, a2 = "os", "lee" // 定义多个变量并赋值

	a3, a4 := "os", "lee" // 简短定义多个变量并赋值

	fmt.Printf("name1: %s, name2: %s, name3: %s\n", name1, name2, name3)
	fmt.Printf("a1: %s, a2: %s, a3: %s, a4: %s\n", a1, a2, a3, a4)
}
package main

import "fmt"

var (
	name     string = "os"
	userName        = "os_lee"
)

func main() {
	fmt.Println(name, userName)
}

4.常量定义

定义的时候就要赋值
赋值之后就不能再修改了

package main

import "fmt"

const name string = "os_lee" // 定义就要赋值

func main() {
	fmt.Println(name)
}

5.命名规范

核心思想:首字母大写的变量、函数。方法,属性可在包外进行访问

6.输出

package main

import "fmt"

func main() {
	fmt.Println("os_lee")
	fmt.Println(1)
	fmt.Println(true)
	fmt.Println("什么", "都", "可以", "输出")
}

格式化输出

package main

import "fmt"

func main() {
    fmt.Printf("%v\n", "你好")           // 可以作为任何值的占位符输出
    fmt.Printf("%v %T\n", "os", "lee") // 打印类型
    fmt.Printf("%d\n", 3)              // 整数
    fmt.Printf("%.2f\n", 1.25)         // 小数
    fmt.Printf("%s\n", "哈哈哈")          // 字符串
    fmt.Printf("%#v\n", "")            // 用go的语法格式输出,很适合打印空字符串

    // 还有一个用的比较多的就是将格式化之后的内容赋值给一个变量
    name := fmt.Sprintf("%v", "你好")
    fmt.Println(name)
}

7.输入 

package main

import "fmt"

func main() {
	fmt.Println("输入您的名字:")
	var name string
	fmt.Scan(&name) // 这里记住,要在变量的前面加个&, 后面讲指针会提到
	fmt.Println("你输入的名字是", name)
}

三、基本数据类型

go语言的基本数据类型有

  1. 整数形
  2. 浮点型
  3. 复数
  4. 布尔
  5. 字符串

1.整数型

go语言的整数类型,具体细分有很多

var n1 uint8 = 2 
var n2 uint16 = 2 
var n3 uint32 = 2 
var n4 uint64 = 2 
var n5 uint = 2 
var n6 int8 = 2 
var n7 int16 = 2 
var n8 int32 = 2 
var n9 int64 = 2 
var n10 int = 2 

大家只需要记住以下几点

  1. 默认的数字定义类型是int类型
  2. 带个u就是无符号,只能存正整数
  3. 后面的数字就是2进制的位数
  4. uint8还有一个别名 byte, 一个字节=8个bit位
  5. int类型的大小取决于所使用的平台

例如uint8,那就是8个二进制位,都用来存储数据,那最小就是0,最大就是2的八次方-1=255

那int8,因为要拿一位存符合,使用实际只有七位可用,所以最小的就是负2的七次方=-128,最大的就是2的七次方-1=127

至于为什么要减一,其实很好理解,因为实际到最后一个数字的时候,已经向前进位了,例如一个小时是60分钟,但是分钟最大只有59

第五点的测试

我是64位操作系统,那么我会试一下int是不是就是int64的最大上限

2的63次方-1=9223372036854775807

fmt.Printf("%.0f\n", math.Pow(2, 63))
var n1 int = 9223372036854775807
fmt.Println(n1)
var n2 int = 9223372036854775808 // 看它报不报错
fmt.Println(n2)

2.浮点型

Go语言支持两种浮点型数:float32 和 float64

  • float32 的浮点数的最大范围约为3.4e38,可以使用常量定义:math.MaxFloat32
  • float64 的浮点数的最大范围约为 1.8e308,可以使用一个常量定义:math.MaxFloat64

如果没有显式声明,则默认是float64

3.字符型

注意哦,是字符,不是字符串

比较重要的两个类型是byte(单字节字符)和rune(多字节字符)

package main

import "fmt"

func main() {
	var c1 = 'a'
	var c2 = 97
	fmt.Println(c1) // 直接打印都是数字
	fmt.Println(c2)

	fmt.Printf("%c %c\n", c1, c2) // 以字符的格式打印

	var r1 rune = '中'
	fmt.Printf("%c\n", r1)
}

在 Go 中,字符的本质是一个整数,直接输出时,是该字符对应的 UTF-8 编码的码值
可以直接给某个变量赋一个数字,然后按格式化输出时 %c ,会输出该数字对应的 unicode 字符
字符类型是可以进行运算的,相当于一个整数,因为它都对应有 Unicode 码。

4.字符串类型

和字符不一样的是,字符的赋值是单引号,字符串的赋值是双引号 

var s string = "lee李"
fmt.Println(s)

转义字符

一些常用的转义字符

fmt.Println("枫枫\t知道")              // 制表符
fmt.Println("枫枫\n知道")              // 回车
fmt.Println("\"枫枫\"知道")            // 双引号
fmt.Println("枫枫\r知道")              // 回到行首
fmt.Println("C:\\pprof\\main.exe") // 反斜杠

多行字符串

在``这个里面,再出现转义字符就会原样输出了

package main

import "fmt"

func main() {
	str := `今天
天气
真好
`
	fmt.Println(str)
}

5.布尔类型

  • 布尔型数据只有 true(真)和 false(假)两个值
  • 布尔类型变量的默认值为false
  • Go 语言中不允许将整型强制转换为布尔型
  • 布尔型无法参与数值运算,也无法与其他类型进行转换
  • 零值问题
    如果我们给一个基本数据类型只声明不赋值,那么这个变量的值就是对应类型的零值,例如int就是0,bool就是false,字符串就是""

package main

import "fmt"

func main() {
	var a1 int
	var a2 float32
	var a3 string
	var a4 bool

	fmt.Printf("%#v\n", a1)
	fmt.Printf("%#v\n", a2)
	fmt.Printf("%#v\n", a3)
	fmt.Printf("%#v\n", a4)
}

四、数组、切片、map

1.数组

数组(Array)是一种非常常见的数据类型,几乎所有的计算机编程语言中都会用到它

  1. 数组里的元素必须全部为同一类型,要嘛全部是字符串,要嘛全部是整数
  2. 声明数组时,必须指定其长度或者大小
package main

import "fmt"

func main() {
	var array [3]int = [3]int{1, 2, 3}
	fmt.Println(array)
	var array1 = [3]int{1, 2, 3}
	fmt.Println(array1)
	var array2 = [...]int{1, 2, 3}
	fmt.Println(array2)
}

 如果要修改某个值,只能根据索引去找然后替换

var array1 = [3]int{1, 2, 3}
array1[0] = 10 // 根据索引找到对应的元素位置,然后替换
fmt.Println(array1)

 2.切片

很明显啊,go里面的数组,长度被限制死了,所以不经常用

所以go出了一个数组plus,叫做slice(切片)

切片(Slice)相较于数组更灵活,因为在声明切片后其长度是可变的

package main

import "fmt"

func main() {
  // 定义一个字符串切片
  var list []string

  list = append(list, "枫枫")
  list = append(list, "知道")
  fmt.Println(list)
  fmt.Println(len(list)) // 切片长度
  // 修改第二个元素
  list[1] = "不知道"
  fmt.Println(list)
}

make函数

除了基本数据类型,其他数据类型如果只定义不赋值,那么实际的值就是nil

// 定义一个字符串切片
var list []string
fmt.Println(list == nil) // true

那么我们可以通过make函数创建指定长度,指定容量的切片了

make([]type, length, capacity)
package main

import "fmt"

func main() {
	// 定义一个字符串切片
	var list = make([]string, 0)
	fmt.Println(list, len(list), cap(list))
	fmt.Println(list == nil) // false

	list1 := make([]int, 2, 2)
	fmt.Println(list1, len(list1), cap(list1))
}

为什么叫切片?
因为切片是数组切出来的

package main

import "fmt"

func main() {
	var list = [...]string{"a", "b", "c"}
	slices := list[:] // 左一刀,右一刀 变成了切片
	fmt.Println(slices)
	fmt.Println(list[1:2]) // b
}

切片排序

package main

import (
	"fmt"
	"sort"
)

func main() {
	var list = []int{4, 5, 3, 2, 7}
	fmt.Println("排序前:", list)
	sort.Ints(list)
	fmt.Println("升序:", list)
	sort.Sort(sort.Reverse(sort.IntSlice(list)))
	fmt.Println("降序:", list)
}

切片面试题 

面试题1:什么是Go语言中的切片?

答案: Go语言中的切片(slices)是一种灵活的、动态大小的、基于数组的抽象数据类型。它并不存储任何数据,而是指向底层数组的一个片段,包含了三个信息:指向数组的指针、长度(len)和容量(cap)。长度表示切片当前拥有的元素个数,容量则是切片可以扩展到的最大元素个数,容量等于或大于长度。

面试题2:切片的扩容是如何工作的?

答案: 当向切片添加元素超出其当前容量时,Go语言会自动扩容切片。扩容的具体策略并不是固定的,但大致遵循以下规则:

  • 如果切片的容量不足以容纳新增元素,Go 会创建一个新的更大的底层数组,将原有数据复制到新数组,并更新切片的指针和容量。
  • 扩容因子通常为原来容量的2倍,但是也可能会根据实际情况调整,比如在Go 1.17版本之后,根据内存分配器的行为,扩容可能会跳跃式增长以更好地适应内存分配器的粒度。
  • 新容量至少会增加到原来的两倍+所需添加的元素数量,以尽量减少频繁的扩容操作。

面试题3:切片与数组有什么区别?

答案

  1. 长度可变性

    • 数组(array)的长度在声明时确定并且不能改变。
    • 切片(slice)虽然在声明时可以指定初始长度,但可以在运行时动态改变其长度(增删元素),不过容量有限制。
  2. 存储结构

    • 数组是一个定长的、连续的内存区域。
    • 切片不是数据结构,它只是一个描述符,指向一个数组的一部分。
  3. 引用行为

    • 数组变量直接存储数据,赋值操作会复制整个数组的内容。
    • 切片变量存储的是指向数组的指针和长度、容量信息,赋值操作只会复制切片描述符,不会复制底层数据。

面试题4:浅拷贝和深拷贝

浅拷贝(Shallow Copy): 浅拷贝是创建一个新的切片,但它仍然指向同一个底层数组。这意味着对新切片所做的修改会影响到原始切片所指向的数据。

// 示例1:直接赋值
original := []int{1, 2, 3}
copied := original // 此时copied是对original的浅拷贝

// 示例2:使用内置的copy函数
original := []int{1, 2, 3}
copied := make([]int, len(original))
copy(copied, original) // 这也是浅拷贝,copied和original共享相同的底层数组

深拷贝(Deep Copy): 深拷贝是创建一个与原始切片完全独立的新切片,包含一个全新的底层数组。对新切片所做的修改不会影响到原始切片。

// 手动循环遍历复制每一个元素
original := []int{1, 2, 3}
copied := make([]int, len(original))
for i, v := range original {
copied[i] = v
}

// 或者使用反射(reflect)包,但请注意这不是最优实践,仅作演示
import "reflect"
original := []int{1, 2, 3}
copied := reflect.ValueOf(original).Clone().Interface().([]int)

3.Map

  1. Go语言中的map(映射、字典)是一种内置的数据结构,它是一个无序的key-value对的集合
  2. map的key必须是基本数据类型,value可以是任意类型
  3. 注意,map使用之前一定要初始化
package main

import "fmt"

func main() {
	// 声明
	var m1 map[string]string
	// 初始化1
	m1 = make(map[string]string)
	// 初始化2
	m1 = map[string]string{}
	// 设置值
	m1["name"] = "枫枫"
	fmt.Println(m1)
	// 取值
	fmt.Println(m1["name"])
	// 删除值
	delete(m1, "name")
	fmt.Println(m1)

	// 声明并赋值
	var m2 = map[string]string{}
	fmt.Println(m2)
	var m3 = make(map[string]string)
	fmt.Println(m3)

}

map取值

  1. 如果只有一个参数接,那这个参数就是值,如果没有,这个值就是类型的零值
  2. 如果两个参数接,那第二个参数就是布尔值,表示是否有这个元素
package main

import "fmt"

func main() {
	// 声明并赋值
	var m1 = map[string]int{
		"age": 21,
	}
	age1 := m1["age1"] // 取一个不存在的
	fmt.Println(age1)
	age2, ok := m1["age1"]
	fmt.Println(age2, ok)
}

map面试题 

面试题1:什么是Go语言中的map?

答案: Go语言中的map是一种关联数组或字典类型的数据结构,它存储键值对(key-value pairs),通过键(key)快速查找对应的值(value)。键和值可以是任何类型,但键的类型必须支持相等比较,通常为整型、浮点型、字符串或复合类型(如结构体,但结构体内的字段必须支持相等比较)。

面试题2:Go语言中的map何时会引发panic?

答案

  • 在使用尚未初始化的map时(即nil map)执行读写操作,会导致panic。
  • 在迭代map的过程中,如果同时修改该map,也会导致panic,除非使用for range循环迭代并在循环体内使用delete函数删除元素。

面试题3:Go语言中map的扩容是如何进行的?

Go语言中的map在底层实现上使用了哈希表。当map中的元素数量越来越多,达到一定的负载因子时,Go语言会自动触发map的扩容操作。扩容是为了保持map操作的高效性,防止哈希冲突过于密集,导致性能下降。

扩容的具体流程如下:

  1. 负载因子判断: 当map的元素数量(entry count)与其桶(bucket)数量的比例超过一定阈值时(通常大约是6.5),map会触发扩容。这个阈值可以通过runtime包的内部常量mapExpandHeapSizemapExpandLoadFactor间接推算出来。

  2. 新桶分配: 扩容时,Go会创建一个新的、大小翻倍的哈希表。例如,如果原map的桶数量是2^N,则新表的桶数量将是2^(N+1)。

  3. 元素迁移: Go采用了渐进式(incremental)的迁移策略,不会一次性将所有元素从旧表迁移到新表。在每次map的读写操作时,如果发现正在进行扩容操作,就会顺带将旧表中的部分元素迁移到新表中。每次操作最多迁移两个桶(bucket)的数据。

  4. 保持引用关系: 在扩容过程中,map的旧表和新表会同时存在,直到所有元素都迁移到新表为止。旧表的最后一个桶会存储一个指向新表的指针,以确保在扩容过程中依然能正确找到已迁移的元素。

  5. 空间回收: 所有元素都迁移到新表后,旧表的空间最终会被垃圾回收机制释放。

值得注意的是,上述细节基于Go语言的早期版本,Go语言的map扩容机制在不同版本间可能会有所调整。最新的Go版本可能会根据具体情况采用不同的扩容策略和负载因子阈值。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/533636.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

基于51单片机的多床位病房呼叫器Proteus仿真

地址:https://pan.baidu.com/s/1WLTBD9WaWncZS_uRSjM-iA 提取码:1234 仿真图: 芯片/模块的特点: AT89C52/AT89C51简介: AT89C52/AT89C51是一款经典的8位单片机,是意法半导体(STMicroelectroni…

企业微信认证后可以修改主体吗?

企业微信变更主体有什么作用?如果原有的公司注销了,或者要更换一家公司主体来运营企业微信,那么就可以进行变更主体,变更主体后才可以保留原来企业微信上的所有用户,否则就只能重新申请重新积累用户了。企业微信变更主…

机器学习和深度学习--李宏毅(笔记与个人理解)Day9

Day9 Logistic Regression(内涵,熵和交叉熵的详解) 中间打了一天的gta5,图书馆闭馆正好npy 不舒服那天天气不好,哈哈哈哈哈总之各种理由吧,导致昨天没弄起来,今天补更! 这里重点注意…

面向对象设计原则实验“依赖倒置原则”

高层模块不应该依赖于低层模块。二者都应该依赖于抽象。抽象不应该依赖于细节。细节应该依赖于抽象。 (开闭原则、里氏代换原则和依赖倒转原则的三个实例很相似,原因是它之间的关系很紧密,在实现很多重构时通常需要同时使用这三个原则。开闭…

【智能优化算法详解】粒子群算法PSO量子粒子群算法QPSO

1.粒子群算法PSO 博主言简意赅总结-算法思想:大方向下个体自学习探索群体交流共享 对比适应度找到最优点 背景 粒子群算法,也称粒子群优化算法或鸟群觅食算法(Particle Swarm Optimization), 缩写为 PSO。粒子群…

HarmonyOS实战开发-如何实现文件管理相关的功能。

介绍 本示例主要展示了文件管理相关的功能,使用ohos.multimedia.medialibrary 、ohos.filemanagement.userFileManager 、ohos.fileio 、ohos.file.fs、ohos.app.ability.contextConstant 等接口,实现了增添文件、删除文件、查找指定类型文件文件、复制…

2024年MathorCup+认证杯数模竞赛思路预定与助攻计划

2024年的第14届“妈妈杯”与认证杯即将启动,云顶数模将团队众多国奖学长学姐将再次为大家精心准备的高质量解题思路、参考代码等,帮助大家在妈妈杯获得理想的成绩,也为国赛奠定坚实基础!! 小云也为大家提供了本周末两场…

安装selenium和关于chrome高版本对应的driver驱动下载安装【Win/Mac 】

目录 一、查看自己电脑上chrome的版本 二、下载 ChromeDriver 三、安装selenium 法一:打开pycharm,点击File,Setting进入配置页面,点击Project下面的Python Interpreter进入环境配置页面,点击。输入selenium。之后…

【太阳能控制器升压芯片方案】DC-DC异步升压恒压外置MOS芯片FP5207 主要应用于太阳能灯带、太阳能路灯/投光灯等市场

随着社会经济的发展,能源危机与生态环境问题日趋严重,大力发展可再生能源已经成为当今世界的必然趋势。太阳能作为取之不尽、清洁干净的资源,已成为世界各国研究开发的热点。光伏发电具有技术成熟、产业化程度高的特点,受到世界各…

一、幼儿园校园广播系统(IP网络广播)建设背景

幼儿园为给儿童提供优雅的学习生活环境,园领导决定建设一套幼儿园校园广播(IP网络广播)系统。 二、幼儿园校园广播系统(IP网络广播)简述 幼儿园校园广播系统(IP网络广播),采用“技…

Linux第88步_非阻塞IO实验

非阻塞IO是“应用程序”对“驱动设备”进行操作,若不能获取到设备资源,则非阻塞IO应用程序的线程不会被“挂起”,即线程不进入休眠,而是一直“轮询”,直到获取到设备资源为止,或者直接放弃。 非阻塞IO应用举…

[计算机效率] 鼠标手势工具:WGestures(解放键盘的超级效率工具)

3.22 鼠标手势工具:WGestures 通过设置各种鼠标手势和操作进行绑定。当用户通过鼠标绘制出特定的鼠标手势后就会触发已经设置好的操作。有点像浏览器中的鼠标手势,通过鼠标手势操纵浏览器做一些特定的动作。这是一款强大的鼠标手势工具,可以…

大语言模型:红蓝对抗的工作原理及作用

您是否对强大的生成式AI领域心生好奇,却又担心随之而来的潜在漏洞?您只需了解红蓝对抗就好了,它也称为破解或提示注入。AI开发的这一关键环节往往被忽视,但其在提高生成式AI模型的性能方面发挥的作用却至关重要。 大语言模型&…

TFT显示屏驱动

REVIEW 已经学习过VGA 时序与实现-CSDN博客 VGA 多分辨率-CSDN博客 今天就来让TFT屏显示一下 小梅哥视频:24 RGB TFT显示屏原理与驱动实现_哔哩哔哩_bilibili 1. 设置显示屏参数与时钟 注意到VGA_parameter.v中,不懂得分辨率对应于不同的频率&#xff…

基于springboot实现洗衣店订单管理系统项目【项目源码+论文说明】

基于springboot实现洗衣店订单管理系统演示 摘要 随着信息互联网信息的飞速发展,无纸化作业变成了一种趋势,针对这个问题开发一个专门适应洗衣店业务新的交流形式的网站。本文介绍了洗衣店订单管理系统的开发全过程。通过分析企业对于洗衣店订单管理系统…

Golang | Leetcode Golang题解之第20题有效的括号

题目&#xff1a; 题解&#xff1a; func isValid(s string) bool {n : len(s)if n % 2 1 {return false}pairs : map[byte]byte{): (,]: [,}: {,}stack : []byte{}for i : 0; i < n; i {if pairs[s[i]] > 0 {if len(stack) 0 || stack[len(stack)-1] ! pairs[s[i]] {…

甘特图在生产进度管理中的应用

生产进度管理在生产制造过程中起着至关重要的作用。 它主要关注对生产进程的掌控和安排&#xff0c;确保生产活动能够按照预定的计划和时间顺利进行&#xff0c;以达到按时交付产品的目标。 在生产进度管理中&#xff0c;首先需要制定一个详细且合理的生产计划&#xff0c;明…

深度学习学习日记4.7

1.梯度下降 w 新 w旧 - 学习率梯度 训练的目的就是让 loss 减小 2.前向传播进行预测&#xff0c; 反向传播进行训练(每一个参数通过梯度下降进行更新参数)&#xff0c;(1前向传播 2求 loss 3反向传播 4梯度更新) 能够让损失下降的参数&#xff0c;就是更好的参数。 损失…

太赫兹探测器是太赫兹技术应用核心器件之一 我国研究成果不断增多

太赫兹探测器是太赫兹技术应用核心器件之一 我国研究成果不断增多 太赫兹探测器&#xff0c;是太赫兹&#xff08;THz&#xff09;应用的基础&#xff0c;是太赫兹成像、太赫兹通信等系统的核心器件&#xff0c;其性能直接决定太赫兹系统的优劣&#xff0c;地位极为重要&#x…

TiDB 组件 GC 原理及常见问题

本文详细介绍了 TiDB 的 Garbage Collection&#xff08;GC&#xff09;机制及其在 TiDB 组件中的实现原理和常见问题排查方法。 TiDB 底层使用单机存储引擎 RocksDB&#xff0c;并通过 MVCC 机制&#xff0c;基于 RocksDB 实现了分布式存储引擎 TiKV&#xff0c;以支持高可用分…