Golang入门基础

文章目录

• 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语言中的函数名、变量名、类型名、包名、方法名、语句标号、等所有的命名，都遵循如下命名规则：

1. 标识符只能由数字、字母和下划线组成。
2. 标识符不能以数字开头，并且严格区分大小写。
3. 标识符中不能包含空格。
4. 不能以单独的_作为标识符。
5. 不能以系统关键字作为标识符。

说明一下：

• 单独的_在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语言明确不支持三元运算符。