Golang入门基础_网站优化分享_上海毫米网络优化公司

您的位置：上海毫米网络优化公司 > 网站优化分享 >

文章目录

Golang的背景知识

Golang的发展历程
Golang的特点
Golang的应用领域
开发环境搭建

下载并安装SDK包
设置环境变量
Go项目目录结构
注释
变量
标识符命名
输入和输出
运算符

算术运算符
关系运算符
逻辑运算符
赋值运算符
位运算符

其他运算符

Golang的背景知识

Golang的发展历程

Golang的核心开发团队

Go语言（又称Golang）是一种静态强类型、编译型、并发型，并具有垃圾回收功能的编程语言，由罗伯特·格瑞史莫（Robert Griesemer）、罗布·派克（Rob Pike）及肯·汤普森（Ken Thompson）于2007年9月开始设计。

Golang入门基础,在这里插入图片描述,第1张

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）。如下：

Golang入门基础,在这里插入图片描述,第2张

点击Download按钮后，根据自己的环境选择对应的SDK安装包下载即可。这里我下载的是Windows操作系统下Go 1.20版本的开发包。如下：

Golang入门基础,在这里插入图片描述,第3张

开发包选择说明：

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语言的编译器、标准库以及其他相关工具和文件的源代码。如下：

Golang入门基础,在这里插入图片描述,第4张

设置环境变量

设置环境变量

安装完Go的开发包后，需要设置如下三个环境变量：

GOROOT：设置为Go开发包的安装路径。
GOPATH：设置为将来开发Go项目的路径。

PATH：添加Go开发包中bin目录的路径。

GOROOT的作用

在Go开发包的src目录中是Go标准库的源代码，其中每一个目录对应一个包，包名与目录名相同，比如fmt目录中存放的就是fmt包相关的源代码。如下：

Golang入门基础,- GOROOT：,第5张

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版本可能不同）：

Golang入门基础,在这里插入图片描述,第6张

go命令提供了编译、构建、运行和测试Go程序的功能，通过go version命令可以查看当前的Go版本。如下：

Golang入门基础,在这里插入图片描述,第7张

gofmt命令用于格式化Go源代码，使其符合Go语言规范的格式。如下：

Golang入门基础,在这里插入图片描述,第8张

gofmt命令默认只会将格式化后的内容输出，如果需要将格式化后的内容写入文件，需要携带-w选项。如下：

Golang入门基础,在这里插入图片描述,第9张

特别注意： Go语言中的左大括号不能单独新起一行，否则会导致编译报错。

Go项目目录结构

Go项目目录结构

Go项目的目录结构没有固定的标准，作为Go初学者，可以使用下面这个简单的目录结构来组织项目。如下：

Golang入门基础,在这里插入图片描述,第10张

说明一下：

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程序。目录结构如下：

Golang入门基础,在这里插入图片描述,第11张

在HelloWorld目录下创建一个main.go文件，并在文件中编写Hello World代码。如下：

package main
import "fmt"
func main() {
	fmt.Printf("Hello Golang")
}

通过go build命令可以对Go程序进行编译，并生成可执行文件。如下：

Golang入门基础,在这里插入图片描述,第12张

说明一下：

通过-o选项可以指明生成的可执行文件的存放路径和文件名。
编译Go程序时，编译器会自动在GOPATH的src目录下寻找Go程序，因此只需从src目录之后开始指明需要编译的Go程序。

Go中的源文件以.go为后缀。

编译后在bin目录下就会生成可执行文件，执行该文件即可输出Hello World。如下：

Golang入门基础,在这里插入图片描述,第13张

此外，也可以通过go run命令直接编译并运行Go程序。如下：

Golang入门基础,在这里插入图片描述,第14张

注释

注释

行注释和块注释：

行注释：//注释内容。

块注释：/*注释内容*/。

例如下面对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中的系统关键字如下：

Golang入门基础,在这里插入图片描述,第15张

系统预定义标识符

Go中的系统预定义标识符如下：

Golang入门基础,在这里插入图片描述,第16张

说明一下：这些预定义标识符包括基础数据类型和系统内建函数等，它们不是关键字，我们可以在定义标识符的时候使用它们，但一般不建议这么做。

输入和输出

通过控制台输出

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语言明确不支持三元运算符。

广东粤数网络建设有限公司家具设计网站智能建站平台开平网红厕所做网站的公司排名嘉兴公司做网站

运算符	描述
&	取地址运算符：返回变量存储的地址
*	解引用运算符：返回指针指向变量的值

上一篇：使用vite+vue+flask实现一个简单的前后端交互效果

下一篇：Navicat、Microsoft SQL Server Management Studio设置ID自增