文章目录
- Golang的背景知识
- Golang的发展历程
- Golang的特点
- Golang的应用领域
- 开发环境搭建
- 下载并安装SDK包
- 设置环境变量
- Go项目目录结构
- 注释
- 变量
- 标识符命名
- 输入和输出
- 运算符
- 算术运算符
- 关系运算符
- 逻辑运算符
- 赋值运算符
- 位运算符
- 其他运算符
Golang的背景知识
Golang的发展历程
Golang的核心开发团队
Go语言（又称Golang）是一种静态强类型、编译型、并发型，并具有垃圾回收功能的编程语言，由罗伯特·格瑞史莫（Robert Griesemer）、罗布·派克（Rob Pike）及肯·汤普森（Ken Thompson）于2007年9月开始设计。
Golang的发展历程
Go语言发展历程如下：
- 2007年9月：Go项目作为Google的一个内部项目开始开发，初衷是创建一门简洁、高效、并发的编程语言。
- 2009年11月：Go语言的第一个正式版本，以开放源代码的方式向全球发布。
- 2012年3月：Go 1.0正式发布，这是Go语言的第一个稳定版本。
- 2016年8月：Go 1.7发布，引入了新的上下文（context）包，用于处理并发任务的取消和超时。
- 2017年2月：Go 1.8发布，引入了对HTTP/2协议的原生支持、新的测试功能和改进的性能。
- 2017年8月：Go 1.9发布，引入了一些小的语言和工具的改进，并对垃圾回收机制进行了优化。
- 2018年2月：Go 1.10发布，该版本带来了更快的编译速度，对WebAssembly的支持和一些语言特性的改进。
- 2018年8月：Go 1.11发布，引入了Go Modules，这时Go语言的官方依赖管理解决方案，用于管理项目的依赖关系。
- 2019年2月：Go 1.12发布，改进了性能和稳定性，包括对垃圾回收器和调度器的优化。
- …
- 2024年2月：Go 1.22发布，这是目前Go的最新版本。
说明一下： 目前Go每半年发布一个二级版本（即从a.x升级到a.y），各个版本详细的更新内容可以在Go官方网站查看。
Golang的特点
Golang的特点
Go语言主要的特点如下：
- 简洁易学： Go语言的语法简洁明了，摒弃了一些繁琐的特性和语法元素，使得代码更易于阅读和维护。这使得Go语言成为一门学习曲线较为平缓的编程语言，即使是没有编程经验的人也能相对轻松地上手。
- 高并发性能： Go语言天生支持并发编程，通过goroutine和channel机制，使得并发编程变得更加简单和安全。开发者可以轻松的利用goroutine来实现并发操作，而无需手动挂历线程和锁，这种并发模型在处理大量请求和高并发场景下特别有优势。
- 内存安全和垃圾回收： Go语言拥有垃圾回收机制，开发者无需手动管理内存分配和回收，大大减轻了编程的负担，同时也有助于防止内存泄漏。
- 强大的标准库： Go语言拥有丰富的标准库，覆盖了网络、文件处理、加密、并发等方面，开发者可以直接利用这些库来实现各种功能，而无需重新编写重复的代码，减少了开发时间和工作量，同时也提高了代码的可维护性。
- 跨平台支持： Go语言支持跨平台开发，可以在多个操作系统上进行编译和运行。开发者可以直接在自己的机器上编译出可执行文件，然后将其部署到不同的操作系统上，而无需进行额外的修改，这种跨平台能力为软件开发人员提供了灵活性和便利性。
- 静态类型语言： Go语言是一门静态类型的编程语言，这意味着在编译期间就能捕获到一些类型相关的错误，这有助于提取发现潜在的bug，减少在运行时可能出现的错误。
- 强调并遵循软件工程原则： Go语言鼓励开发者编写清晰、简介、可维护的代码，它有一套明确的代码风格规范，并自带了一些工具来帮助开发者保持一致的代码风格。
- 丰富的生态系统： Go语言的社区非常活跃，有着庞大的开发者群体，社区中不断推出新的开源项目和工具，这意味着开发者可以轻松地获取到丰富的资源和文档，解决问题变得的更加便捷。
Golang的应用领域
Golang的应用领域
Go语言目前主要的应用领域如下：
- 后端开发： Go语言的并发性能额高效的网络编程使其成为构建高性能、可扩展的后端服务的理想选择，许多Web应用、RESTful API服务、微服务架构都广泛使用Go语言进行开发。
- 云计算和分布式系统： Go语言的并发模型和轻量级线程（goroutine）机制使得它在构建云计算和分布式系统方面表现出色，许多云服务提供商和分布式系统都采用Go语言编写，如Docker、Kubernetes等。
- 数据库和存储系统： Go语言优秀的并发性能使它适用于构建高性能的数据库和存储系统，许多数据库和存储系统都采用Go语言进行开发，如etcd、BoltDB等。
- 嵌入式系统： 尽管Go语言是一门高级编程语言，但其高效的编译速度和小巧的二进制文件，使得它在嵌入式系统领域也有所应用。Go语言可以用于编写一些轻量级的嵌入式系统和物联网设备。
- DevOps工具： 由于Go语言的高效编译和跨平台特性，使得它在开发和运维工具方面也得到广泛应用，许多DevOps工具都是用Go语言编写的，如Terraform、Prometheus等。
开发环境搭建
下载并安装SDK包
下载SDK包
搭建Go开发环境，首先需要在Go官方网站下载Go的软件开发工具包（Software Development Kit，SDK）。如下：
点击Download按钮后，根据自己的环境选择对应的SDK安装包下载即可。这里我下载的是Windows操作系统下Go 1.20版本的开发包。如下：
开发包选择说明：
- Mac操作系统：选择文件名中包含darwin的开发包。
- Unix操作系统：选择文件名中包含freebsd的开发包。
- Linux操作系统：选择文件名中包含Linux的开发包。
- Windows操作系统：选择文件名中包含Windows的开发包。
- 32位操作系统：选择文件名中包含386的开发包。
- 64位操作系统：选择文件名中包含amd64的开发包。
- 图形化安装包：Windows操作系统选择文件名后缀为.msi的开发包，Mac操作系统选择文件名后缀为.pkg的开发包。
- 解压即使用安装包：Windows操作系统选择文件名后缀为.zip的开发包，其他操作系统选择文件名后缀为.tar.gz的开发包。
注：gox.xx.src.tar.gz中存放的是对应版本的Go源代码。
安装SDK包
由于我下载的是解压即使用类型的安装包，因此只需将文件解压即可，解压后即可得到Go语言的编译器、标准库以及其他相关工具和文件的源代码。如下：
设置环境变量
设置环境变量
安装完Go的开发包后，需要设置如下三个环境变量：
- GOROOT：设置为Go开发包的安装路径。
- GOPATH：设置为将来开发Go项目的路径。
- PATH：添加Go开发包中bin目录的路径。
GOROOT的作用
在Go开发包的src目录中是Go标准库的源代码，其中每一个目录对应一个包，包名与目录名相同，比如fmt目录中存放的就是fmt包相关的源代码。如下：
GOROOT的作用：
- 在编写Go程序的过程中要使用标准库，需要通过import关键字指定包名进行引入。
- 编译器在编译Go程序时，会自动在GOROOT下的src目录中找到对应的标准库包。
- 如果没有正确设置GOROOT环境变量，那么在编译Go程序时就会报错
cannot find package。
GOPATH的作用
GOPATH的作用：
- 在编写Go程序时，为了提高程序的可维护性和可读性，我们会将代码以包的形式进行划分，形成独立的功能模块或库，通过import关键字同样可以引入我们自己创建的包。
- 编译器在编译Go程序时，如果在GOROOT下的src目录中找不到import的包，那么会继续在GOPATH下的src目录中寻找。
- 如果没有正确设置GOPATH环境变量，并且在Go程序中引用了自己创建的包，那么在编译Go程序时同样会报错
cannot find package。
PATH的作用
PATH的作用：
- PATH环境变量用于指定系统可执行文件的搜索路径，我们之所以能够在命令行中执行cmd命令，是因为这些命令对应的可执行文件所在的目录都被添加到了PATH环境变量中。
- Go开发包中的bin目录下存放的就是常用的Go相关的命令和工具，为了能够在任意路径下执行这些命令，因此需要将该目录添加到PATH环境变量中。
Go开发包中的bin目录下的可执行文件如下（不同Go版本可能不同）：
go命令提供了编译、构建、运行和测试Go程序的功能，通过go version命令可以查看当前的Go版本。如下：
gofmt命令用于格式化Go源代码，使其符合Go语言规范的格式。如下：
gofmt命令默认只会将格式化后的内容输出，如果需要将格式化后的内容写入文件，需要携带-w选项。如下：
特别注意： Go语言中的左大括号不能单独新起一行，否则会导致编译报错。
Go项目目录结构
Go项目目录结构
Go项目的目录结构没有固定的标准，作为Go初学者，可以使用下面这个简单的目录结构来组织项目。如下：
说明一下：
- src目录用于存放Go源代码，bin目录用于存放生成的可执行文件，config目录用于存放项目的配置文件。
- 考虑到项目可能用到第三方库，而go get命令下载的第三方库是放在GOPATH的src目录下的，比如在github下载的第三方库代码，会存放在src目录下的github.com目录中。为了更好的管理项目代码，可以在src目录下创建一个go_code目录，将项目代码统一放在go_code目录下。
- 对于每一个Go项目来说，如果项目比较庞大，可以在project目录下按包创建多个子目录存放项目代码，如果项目比较简单，也可以直接在project目录下创建一个go文件。
- Go项目目录结构中的src目录名不能改为其他名字，因为Go项目引入非标准库包时，固定是在GOPATH的src目录下找的。在通过import关键字指定引入非标准库包时，只需要从src开始（不包含src）指明包目录的路径即可。
Hello World程序
本篇博客介绍Golang的一些入门知识，于是我在go_code目录下创建了BasicKnowledge目录，用于存放本篇博客的所有代码，并在BasicKnowledge目录下创建了一个HelloWorld目录，用于编写Hello World程序。目录结构如下：
在HelloWorld目录下创建一个main.go文件，并在文件中编写Hello World代码。如下：
package main
import "fmt"
func main() {
fmt.Printf("Hello Golang")
}
通过go build命令可以对Go程序进行编译，并生成可执行文件。如下：
说明一下：
- 通过
-o选项可以指明生成的可执行文件的存放路径和文件名。 - 编译Go程序时，编译器会自动在GOPATH的src目录下寻找Go程序，因此只需从src目录之后开始指明需要编译的Go程序。
- Go中的源文件以
.go为后缀。
编译后在bin目录下就会生成可执行文件，执行该文件即可输出Hello World。如下：
此外，也可以通过go run命令直接编译并运行Go程序。如下：
注释
注释
行注释和块注释：
- 行注释：
//注释内容。 - 块注释：
/*注释内容*/。
例如下面对Hello World代码进行了简单注释。如下：
package main // 将当前文件声明为main包
import "fmt" //引入fmt包
/*这是主函数*/
func main() {
// 调用fmt包的Printf函数输出Hello World
fmt.Printf("Hello World")
}
说明一下：
- Go是以包的形式来管理文件的，每一个go文件都必须归属于一个包，main包中的main函数是整个程序执行时的入口。
变量
变量语法
Go中通过var关键字声明变量，如果待声明的变量的类型相同，则可以同时声明多个变量。如下：
var s string // 声明单个变量
var n1, n2, n3 int // 声明多个同类型变量
如果在声明变量的同时给变量赋值，那么变量的数据类型可以省略，让编译器自行推导。此外，还可以直接以变量名 := 表达式的形式声明变量，变量的类型将根据表达式自动推导。如下：
// 声明单个变量并赋值
var s1 string = "dragon"
var s2 = "dragon"
s3 := "dragon"
// 声明多个同类型变量并赋值
var n1, n2, n3 int = 10, 20, 30
var n4, n5, n6 = 10, 20, 30
n7, n8, n9 := 10, 20, 30
在声明多个变量时，如果给这些变量赋值，那么这些不同类型的变量也可以同时声明。如下：
// 声明多个不同类型变量
var s1, n1 = 10, "dragon"
s2, n2 := 10, "dragon"
此外，也可以通过下面这种方式进行多变量声明，这种方式通常用于声明全局变量。如下：
// 多变量声明
var (
s1 string = "dragon"
n1 int = 10
s2 = "dragon" // 类型可以省略
n2 = 10 // 类型可以省略
)
注意： Go中不能以变量名 := 表达式的方式声明全局变量。
变量作用域
以下是各种变量对应的作用域：
- 包级别变量：在函数外定义的全局变量，在整个包有效，可以在同一包内的所有文件中被访问。如果变量名首字母大写，则在整个程序有效，可以在所有包中被访问。
- 函数级别变量：在函数内部定义的变量，只在该函数内部有效。
- 块级别变量：在代码块内部定义的变量，只在该代码块内部有效。
- 函数参数：函数参数在函数内部有效，其作用域等同于函数内部定义的变量。
说明一下：
- Go中的每个文件都必须归属于一个包，并不意味着一个包只能对应一个文件，Go中通常以包名作为目录名，该目录下的所有go文件都归属于这个包。
- 包中变量名首字母小写的全局变量只能被该包内的文件访问，称该变量不可导出；包中变量名首字母大写的全局变量可以被其他包以
包名.变量名的形式访问，称该变量可导出。
标识符命名
命名规范
Go语言中的函数名、变量名、类型名、包名、方法名、语句标号、等所有的命名，都遵循如下命名规则：
- 标识符只能由数字、字母和下划线组成。
- 标识符不能以数字开头，并且严格区分大小写。
- 标识符中不能包含空格。
- 不能以单独的
_作为标识符。 - 不能以系统关键字作为标识符。
说明一下：
- 单独的
_在Go中称为空标识符，它可以代表任何其他的标识符，但它对应的值会被忽略，所以仅能作为占位符使用（比如忽略函数的某个返回值），不能作为标识符。 - 标识符命名采用驼峰命名法，如果包中的变量名、函数名、常量名、方法名首字母大写，则可以被其他包访问；如果首字母小写则只能在本包中使用。
系统关键字
Go中的系统关键字如下：
系统预定义标识符
Go中的系统预定义标识符如下：
说明一下： 这些预定义标识符包括基础数据类型和系统内建函数等，它们不是关键字，我们可以在定义标识符的时候使用它们，但一般不建议这么做。
输入和输出
通过控制台输出
Go中通常使用fmt包中的Println和Printf函数向控制台输出数据。如下：
package main
import "fmt"
func main() {
// 输出一行数据
fmt.Println("Hello", "Golang") // Hello Golang
// 格式化输出
var name string = "2021dragon"
fmt.Printf("your id is %s\n", name) // your id is 2021dragon
}
说明一下：
- Println函数：采用默认格式将其参数格式化并写入标准输出，输出时会在相邻参数之间添加空格，并在输出结束后添加换行符。
- Printf函数：根据指定的格式生成格式化后的字符串，并写入标准输出。
通过控制台输入
Go中通常使用fmt包中的Scanln和Scanf函数从控制台读取数据。如下：
package main
import "fmt"
func main() {
// 输入一行数据
var str1 string
fmt.Scanln(&str1)
fmt.Printf("%s\n", str1)
// 格式化输入
var str2 string
fmt.Scanf("%s\n", &str2)
fmt.Printf("%s\n", str2)
}
说明一下：
- Scanln函数：从标准输入读取数据，直到读取到换行符或到达结束位置。
- Scanf函数：从标准输入读取数据，根据指定的格式将读取到的值保存到对应的参数中。
运算符
算术运算符
算术运算符
Go中的算术运算符如下：
| 运算符 | 描述 |
|---|---|
| + | 正号 |
| - | 负号 |
| + | 加 |
| - | 减 |
| * | 乘 |
| / | 除 |
| % | 取模 |
| ++ | 自增 |
| – | 自减 |
| + | 字符串相加 |
使用案例如下：
package main
import "fmt"
func main() {
// 算术运算符
var num1 = +25
var num2 = -10
var num3 = num1 + num2
var num4 = num1 - num2
var num5 = num1 * num2
var num6 = num1 / num2
var num7 = num1 % num2
num1++
num2--
var s = "2021" + "dragon"
fmt.Printf("num1 = %d\n", num1) // 26
fmt.Printf("num2 = %d\n", num2) // -11
fmt.Printf("num3 = %d\n", num3) // 15
fmt.Printf("num4 = %d\n", num4) // 35
fmt.Printf("num5 = %d\n", num5) //-250
fmt.Printf("num6 = %d\n", num6) // -2
fmt.Printf("num7 = %d\n", num7) // 5
fmt.Printf("s = %s\n", s) // 2021dragon
}
注意：
- 参与算术运算符的两个操作数类型必须相同，运算结果也是对应类型。
- 对于取模运算来说， a % b a\%b a%b 等价于 a − b ÷ b ∗ b a-b \div b*b a−b÷b∗b，有负数参与运算也适用。
- Go中的自增和自减只能当做一个独立语句使用，并且只有后置++和后置–，没有前置++和前置–。
关系运算符
关系运算符
Go中的关系运算符如下：
| 运算符 | 描述 |
|---|---|
| == | 等于 |
| != | 不等于 |
| < | 小于 |
| > | 大于 |
| <= | 小于等于 |
| >= | 大于等于 |
使用案例如下：
package main
import "fmt"
func main() {
// 关系运算符
var num1, num2 = 10, 20
fmt.Println(num1 == num2) // false
fmt.Println(num1 != num2) // true
fmt.Println(num1 < num2) // true
fmt.Println(num1 > num2) // false
fmt.Println(num1 <= num2) // true
fmt.Println(num1 >= num2) // false
}
逻辑运算符
逻辑运算符
Go中的逻辑运算符如下：
| 运算符 | 描述 |
|---|---|
| && | 逻辑与：如果两边的操作数都为true，则为true，否则为false |
| | | | 逻辑或：如果两边的操作数有一个为true，则为true，否则为false |
| ! | 逻辑非：如果条件为true，则为false，否则为true |
使用案例如下：
package main
import "fmt"
func main() {
// 逻辑运算符
var num1, num2 = 10, 20
fmt.Println(num1 > 0 && num2 > 0) // true
fmt.Println(num1 > 10 || num2 > 10) // true
fmt.Println(!(num1 > num2)) // true
}
注意：
- 短路与：如果&&的第一个条件为false，则不再判断第二个条件，最终结果为false。
- 短路或：如果| |的第一个条件为true，则不再判断第二个条件，最终结果为true。
赋值运算符
赋值运算符
Go中的赋值运算符如下：
| 运算符 | 描述 |
|---|---|
| = | 直接赋值 |
| += | 相加后再赋值 |
| -= | 相减后再赋值 |
| *= | 相乘后再赋值 |
| /= | 相除后再赋值 |
| %= | 求余后再赋值 |
| <<= | 左移后再赋值 |
| >>= | 右移后再赋值 |
| &= | 按位与后再赋值 |
| |= | 按位或后再赋值 |
| ^= | 按位异或后再赋值 |
使用案例如下：
package main
import "fmt"
func main() {
// 赋值运算符
var num1, num2 = 10, 20
num1 = num2 // num1 = 20, num2 = 20
num1 += 10 // num1 = 30, num2 = 20
num2 -= 10 // num1 = 30, num2 = 10
num1 *= 2 // num1 = 60, num2 = 10
num2 /= 5 // num1 = 60, num2 = 2
num1 %= 8 // num1 = 4, num2 = 2
num1 <<= 1 // num1 = 8, num2 = 2
num2 >>= 1 // num1 = 8, num2 = 1
num1 &= num2 // num1 = 0, num2 = 1
num1 |= 4 // num1 = 4, num2 = 1
num2 ^= num1 // num1 = 4, num2 = 5
fmt.Printf("num1 = %d, num2 = %d\n", num1, num2) // num1 = 4, num2 = 5
}
位运算符
位运算符
Go中的位运算符如下：
| 运算符 | 描述 |
|---|---|
| & | 按位与：将两个操作数进行按位与操作（同时为1，结果为1，否则为0） |
| | | 按位或：将两个操作数进行按位或操作（有一个为1，结果为1，否则为0） |
| ^ | 按位异或：将两个操作数进行按位异或操作（相同为0，相异为1） |
| << | 左移运算符：将左操作数的二进制序列左移若干位（低位补0，高位丢弃，符号位不变） |
| >> | 右移运算符：将左操作数的二进制序列右移若干位（低位丢弃，高位补符号位的值，符号位不变） |
使用案例如下：
package main
import "fmt"
func main() {
// 位运算符
var num1, num2 = 12, -4
// 00...01100 --> 12的原码、反码、补码：
// 10...00100 --> -4的原码
// 11...11011 --> -4的反码
// 11...11100 --> -4的补码
fmt.Println(num1 & num2) // 00...01100 -> 12
fmt.Println(num1 | num2) // 11...11100 -> -4
fmt.Println(num1 ^ num2) // 11...10000 -> 11...01111 -> 10...10000 -> -16
fmt.Println(num1 << 2) // 48
fmt.Println(num2 >> 2) // 11...11111 -> -1
}
注意：
- 计算机在进行位运算的时候，都是以补码的方式来运算的。
- 原码的符号位不变，其他位按位取反得到反码，反码加一得到补码。
其他运算符
其他运算符
Go中其他的运算符如下：
| 运算符 | 描述 |
|---|---|
| & | 取地址运算符：返回变量存储的地址 |
| * | 解引用运算符：返回指针指向变量的值 |
使用案例如下：
package main
import "fmt"
func main() {
// 其他运算符
var num = 10
fmt.Printf("num的地址是%p\n", &num) // num的地址是0xc00000e0b8
var ptr = &num
*ptr = 20
fmt.Printf("num = %d\n", num) // 20
}
特别说明： Go语言明确不支持三元运算符。
![[蓝桥杯 | 暴搜] 学会暴搜之路](https://img-blog.csdnimg.cn/direct/3ffb2a8342f443b59400979335511b44.png)
