快速学习GO语言总结
备注：本博客将自己初步学习GO的总结进行分享，希望大家通过本博客可以在短时间内快速掌握GO的基本程序编码能力，如有错误请留言指正，谢谢！
一、初步了解Go语言
（一）Go语言诞生的主要问题和目标
-
多核硬件架构： 随着计算机硬件的发展，多核处理器成为主流，使得并行计算变得普遍。然而，传统的编程语言在处理多核并行性时可能面临困难，因为它们缺乏合适的原生支持。Go语言通过引入轻量级的协程（goroutine）和通道（channel）机制，使得并发编程变得更加容易。开发者可以轻松地创建数千个并发执行的协程，而无需担心线程管理的复杂性。
-
超大规模分布式计算集群： 随着云计算和分布式系统的崛起，构建和维护超大规模的分布式计算集群变得越来越常见。这些集群需要能够高效处理大量的请求、数据共享和协调。Go语言的并发特性和通道机制使得编写分布式系统变得更加容易，开发者可以使用协程和通道来处理并发任务、消息传递和协调工作。
-
Web模式导致的开发规模和更新速度增加： Web应用的兴起带来了前所未有的开发规模和持续更新的需求。传统的编程语言在开发大型Web应用时可能会面临可维护性、性能和开发效率等问题。Go语言通过其简洁的语法、高效的编译速度以及并发支持，使得开发者能够更快速地迭代和部署Web应用，同时也能够更好地处理高并发的网络请求。
综合来看，Go语言在诞生时确实着重解决了多核硬件架构、超大规模分布式计算集群和Web模式下的开发规模与速度等技术挑战。它的设计目标之一是提供一种适应现代软件开发需求的编程语言，使开发者能够更好地应对这些挑战。
（二）Go语言应用典型代表
Go语言在当下应用开发中已经得到广泛应用，许多知名公司和项目都使用Go语言来构建各种类型的应用。以下是一些代表性的产品和项目，它们使用了Go语言作为核心开发语言：
这些仅仅是Go语言应用的一小部分示例，实际上还有许多其他的项目和产品也在使用Go语言来构建高性能、可靠且易于维护的应用程序。这表明Go语言在现代应用开发中发挥了重要作用，特别是在分布式系统、云计算和高性能应用领域。
（三）Java、C++、C程序员在学习编写Go时存在的误区
当Java、C++、C等编程语言的程序员开始学习编写Go语言时，可能会遇到一些误区，因为Go在某些方面与这些传统语言有所不同。以下是一些常见的误区：
-
过度使用传统的并发模型： 传统的编程语言如Java、C++、C在处理并发时通常使用线程和锁来实现，但在Go中，使用协程（goroutine）和通道（channel）是更好的方式。新学习Go的程序员可能会继续使用传统的并发模型，而不充分利用Go的轻量级协程和通道，从而失去了Go的并发优势。
-
过度使用指针： C和C++等语言强调指针的使用，但Go语言在设计时避免了过多的指针操作。新学习Go的程序员可能会过度使用指针，导致代码变得复杂。在Go中，尽量避免使用指针，除非真正需要对值进行修改。
-
忽视错误处理： Go鼓励显式地处理错误，而不是简单地忽略它们。这与一些其他语言的习惯不同，其中错误往往被忽略或简单地抛出。新学习Go的程序员可能会忽视错误处理，导致潜在的问题未被检测到。
-
过度使用全局变量： 在C和C++等语言中，全局变量可能是常见的做法。然而，在Go中，全局变量的使用被视为不良实践。Go鼓励使用局部变量和传递参数的方式来传递数据，以避免引入不必要的耦合和副作用。
-
不熟悉切片和映射： Go中的切片和映射是强大的数据结构，但对于其他语言的程序员来说可能不太熟悉。学习如何正确使用切片和映射是很重要的，因为它们在Go中广泛用于集合和数据处理。
-
错误的Go风格： 每种语言都有其独特的编码风格和惯例。新学习Go的程序员可能会在Go代码中应用其他语言的编码风格，这可能会使代码难以阅读和理解。了解和遵循Go的编码规范是很重要的。
为了避免这些误区，学习Go的程序员应该投入时间去理解Go语言的核心概念，包括并发模型、错误处理、数据结构等，同时积极参与Go社区，阅读Go的官方文档和示例代码，以便更好地适应Go的设计理念和最佳实践。
二、环境准备（以Mac说明）
（一）环境设置
在macOS上设置Go语言开发环境非常简单，您可以按照以下步骤进行操作：
-
使用Homebrew安装： 如果您使用Homebrew包管理器，这是最方便的方法。打开终端，并运行以下命令来安装Go语言：
brew install go -
手动安装： 如果您希望手动安装Go语言，可以按照以下步骤操作：
a. 访问官方网站下载安装包`goX.X.X.darwin-amd64.pkg
b. 双击下载的安装包，按照指示运行安装程序。按照默认设置即可，安装路径通常是
/usr/local/go。 -
设置环境变量： 一旦安装完成，您需要将Go语言的二进制路径添加到您的终端配置文件中的PATH环境变量中。这样您就可以在终端中直接运行Go命令。
a. 打开终端，并使用文本编辑器（如nano、vim或任何您喜欢的编辑器）编辑您的终端配置文件。例如：
nano ~/.bash_profileb. 在文件中添加以下行（根据您的安装路径进行调整），然后保存并退出编辑器：
export PATH=$PATH:/usr/local/go/binc. 使配置生效，可以运行以下命令或者重启终端：
source ~/.bash_profile -
验证安装： 打开终端，输入以下命令来验证Go是否已正确安装：
go version如果您看到了Go的版本号，表示安装成功。
（二）IDE选择说明
我个人使用的GoLand，直接官网下载后，上网购买破解版即可，这里不在多说！
三、Go语言程序学习
创建自己的工程目录/Users/zyf/zyfcodes/go/go-learning，新建src目录。
（一）第一个Go语言编写
src目录下创建chapter1/hello目录，新建hello.go文件，编写代码如下：
package main
import (
"fmt"
"os"
)
/**
* @author zhangyanfeng
* @description 第一个godaima
* @date 2023/8/20 23:45
* @param
* @return
**/
func main() {
if len(os.Args) > 1 {
fmt.Println("Hello World", os.Args[1])
}
}
这段代码是一个简单的Go语言程序，它接受命令行参数并打印出一条带参数的 "Hello World" 消息。下面是对代码的逐行分析：
-
package main: 声明这个文件属于名为 "main" 的包，这是一个Go程序的入口包名。 -
import ("fmt" "os"): 引入了两个标准库包，分别是 "fmt" 用于格式化输出，和 "os" 用于与操作系统交互。 -
func main() { ... }: 这是程序的入口函数，它会在程序运行时首先被调用。 -
if len(os.Args) > 1 { ... }: 这个条件语句检查命令行参数的数量是否大于1，也就是判断是否有参数传递给程序。os.Args是一个字符串切片，它包含了所有的命令行参数，第一个参数是程序的名称。 -
fmt.Println("Hello World", os.Args[1]): 如果有参数传递给程序，就会执行这行代码。它使用fmt.Println函数打印一条消息，消息由字符串 "Hello World" 和os.Args[1]组成，os.Args[1]表示传递给程序的第一个参数。
综上所述，这段代码涵盖了以下知识点：
-
包导入和使用标准库：通过
import关键字导入 "fmt" 和 "os" 包，然后在代码中使用这些包提供的函数和类型。 -
命令行参数获取：使用
os.Args获取命令行参数。 -
条件语句：使用
if条件语句来判断是否有命令行参数传递给程序。 -
字符串操作：使用字符串连接操作将 "Hello World" 与命令行参数拼接在一起。
-
格式化输出：使用
fmt.Println函数将消息输出到标准输出。
注意：如果没有传递参数给程序，那么这段代码不会打印任何消息。如果传递了多个参数，代码只会使用第一个参数并忽略其他参数。
在该目录下执行“go run hello.go ZYF”，运行结果为“Hello World ZYF”。
（二）基本程序结构编写学习
src目录下创建chapter2
1.变量
前提：chapter2目录下创建variables，学习总结如下：
- 变量声明： 使用
var关键字声明一个变量，例如：var x int。 - 类型推断： 可以使用
:=操作符进行变量声明和赋值，Go会根据右侧的值自动推断变量类型，例如：y := 5。 - 变量赋值： 使用赋值操作符
=给变量赋值，例如：x = 10。 - 多变量声明： 可以同时声明多个变量，例如：
var a, b, c int。 - 变量初始化： 变量可以在声明时进行初始化，例如：
var name string = "John"。 - 零值： 未初始化的变量会被赋予零值，数字类型为0，布尔类型为
false，字符串类型为空字符串等。 - 短变量声明： 在函数内部，可以使用短变量声明方式，例如：
count := 10。
新建fib_test.go，背景：简单实用斐波那契数列进行练习
package variables
import "testing"
func TestFibList(t *testing.T) {
a := 1
b := 1
t.Log(a)
for i := 0; i < 5; i++ {
t.Log(" ", b)
tmp := a
a = b
b = tmp + a
}
}
func TestExchange(t *testing.T) {
a := 1
b := 2
// tmp := a
// a = b
// b = tmp
a, b = b, a
t.Log(a, b)
}
下面逐个解释代码中涉及的知识点：
-
package variables: 声明了一个名为 "variables" 的包，这是一个用于测试的包名。 -
import "testing": 导入了Go语言的测试框架 "testing" 包，用于编写和运行测试函数。 -
func TestFibList(t *testing.T) { ... }: 定义了一个测试函数 "TestFibList"，该函数用于测试斐波那契数列生成逻辑。这是一个测试函数的标准命名，以 "Test" 开头，接着是被测试的函数名。- 在测试函数内部，声明了两个整数变量
a和b，并将它们初始化为 1，这是斐波那契数列的前两个数。 - 使用
t.Log(a)打印变量a的值到测试日志中。 - 使用循环来生成斐波那契数列的前 5 个数，每次迭代都会将
b的值打印到测试日志，并更新a和b的值以生成下一个数。
- 在测试函数内部，声明了两个整数变量
-
func TestExchange(t *testing.T) { ... }: 定义了另一个测试函数 "TestExchange"，该函数用于测试变量交换的逻辑。- 在测试函数内部，声明了两个整数变量
a和b，并分别将它们初始化为 1 和 2。 - 使用注释的方式展示了一种变量交换的写法（通过中间变量），但实际上被注释掉了。然后使用
a, b = b, a这一行代码来实现a和b的交换，这是Go语言中的一种特有的交换方式，不需要额外的中间变量。 - 使用
t.Log(a, b)打印交换后的变量值到测试日志中。
- 在测试函数内部，声明了两个整数变量
2.常量
前提：chapter2目录下创建constant，学习总结如下：
- 常量声明： 使用
const关键字声明一个常量，例如：const pi = 3.14159。 - 常量赋值： 常量的值在声明时必须被赋值，一旦赋值后不可修改。
- 枚举常量： 可以使用一组常量来模拟枚举，例如：
const ( Monday = 1 Tuesday = 2 // ... ) - 类型指定： 常量的类型也可以被指定，例如：
const speed int = 300000。 - 常量表达式： 常量可使用表达式计算，例如：
const secondsInHour = 60 * 60。 - 无类型常量： 常量可以是无类型的，根据上下文自动推断类型。例如，
const x = 5会被推断为整数类型。
新建constant_test.go，写代码如下：
package constant
import "testing"
const (
Monday = 1 + iota
Tuesday
Wednesday
)
const (
Readable = 1 << iota
Writable
Executable
)
func TestConstant1(t *testing.T) {
t.Log(Monday, Tuesday)
}
func TestConstant2(t *testing.T) {
a := 1 //0001
t.Log(a&Readable == Readable, a&Writable == Writable, a&Executable == Executable)
}下面逐个解释代码中涉及的知识点：
-
package constant: 声明了一个名为 "constant" 的包，这是一个用于测试的包名。 -
import "testing": 导入了Go语言的测试框架 "testing" 包，用于编写和运行测试函数。 -
const (...): 定义了两个常量块。-
第一个常量块中，使用了
iota常量生成器来定义了一系列从 1 开始递增的常量。在这个例子中，Monday被赋值为 1，Tuesday被赋值为 2，Wednesday被赋值为 3。iota在常量块中每次被使用时会递增一次，因此后续的常量会依次递增。 -
第二个常量块中，使用了
iota来定义了一系列按位左移的常量。在这个例子中，Readable被赋值为 1，Writable被赋值为 2（二进制中的 10），Executable被赋值为 4（二进制中的 100）。位运算中，左移操作可以将二进制数向左移动指定的位数。
-
-
func TestConstant1(t *testing.T) { ... }: 定义了一个测试函数 "TestConstant1"，用于测试第一个常量块中定义的常量。- 使用
t.Log(Monday, Tuesday)打印常量Monday和Tuesday的值到测试日志中。
- 使用
-
func TestConstant2(t *testing.T) { ... }: 定义了另一个测试函数 "TestConstant2"，用于测试位运算和常量的使用。- 在测试函数内部，声明了一个整数变量
a，并将其初始化为 1，即二进制中的 0001。 - 使用位运算和按位与操作来检查变量
a是否具有Readable、Writable和Executable属性。例如，a&Readable == Readable表达式检查a的二进制表示是否含有Readable标志位。 - 使用
t.Log()打印三个表达式的结果到测试日志中。
- 在测试函数内部，声明了一个整数变量
3.数据类型
前提：chapter2目录下创建 type，学习总结如下：
主要数据类型说明
Go语言具有丰富的内置数据类型，这些数据类型用于表示不同类型的值和数据。以下是对Go语言中一些主要数据类型的总结分析：
-
整数类型（Integer Types）：Go语言提供不同大小的整数类型，如
int、int8、int16、int32和int64。无符号整数类型有uint、uint8、uint16、uint32和uint64。整数类型的大小取决于计算机的架构，例如32位或64位。 -
浮点数类型（Floating-Point Types）：Go语言提供
float32和float64两种浮点数类型，分别对应单精度和双精度浮点数。 -
复数类型（Complex Types）：Go语言提供
complex64和complex128两种复数类型，分别对应由两个浮点数构成的复数。 -
布尔类型（Boolean Type）：布尔类型用于表示真（
true）和假（false）的值，用于条件判断和逻辑运算。 -
字符串类型（String Type）：字符串类型表示一系列字符。字符串是不可变的，可以使用双引号
"或反引号`来定义。 -
字符类型（Rune Type）：字符类型
rune用于表示Unicode字符，它是int32的别名。通常使用单引号'来表示字符，如'A'。 -
数组类型（Array Types）：数组是具有固定大小的同类型元素集合。声明数组时需要指定元素类型和大小。
-
切片类型（Slice Types）：切片是对数组的一层封装，是动态长度的可变序列。切片不保存元素，只是引用底层数组的一部分。
-
映射类型（Map Types）：映射是键值对的无序集合，用于存储和检索数据。键和值可以是任意类型，但键必须是可比较的。
-
结构体类型（Struct Types）：结构体是一种用户定义的复合数据类型，可以包含不同类型的字段，每个字段有一个名字和类型。
-
接口类型（Interface Types）：接口是一种抽象类型，用于定义一组方法。类型实现了接口的方法集合即为实现了该接口。
-
函数类型（Function Types）：函数类型表示函数的签名，包括参数和返回值类型。函数可以作为参数传递和返回。
-
通道类型（Channel Types）：通道是用于在协程之间进行通信和同步的一种机制。通道有发送和接收操作。
-
指针类型（Pointer Types）：指针类型表示变量的内存地址。通过指针可以直接访问和修改变量的值。
Go语言的数据类型具有清晰的语法和语义，支持丰富的内置功能。合理选择和使用不同的数据类型可以提高程序的效率和可读性。
具体代码展开分析
package main
import "fmt"
type Person struct {
FirstName string
LastName string
Age int
}
type Shape interface {
Area() float64
}
type Circle struct {
Radius float64
}
func (c Circle) Area() float64 {
return 3.14 * c.Radius * c.Radius
}
func add(a, b int) int {
return a + b
}
func subtract(a, b int) int {
return a - b
}
type Operation func(int, int) int
func main() {
fmt.Println("整数类型（Integer Types）")
var x int = 10
var y int64 = 100
fmt.Println(x)
fmt.Println(y)
fmt.Println("浮点数类型（Floating-Point Types）")
var a float32 = 3.14
var b float64 = 3.14159265359
fmt.Println(a)
fmt.Println(b)
fmt.Println("布尔类型（Boolean Type）")
var isTrue bool = true
var isFalse bool = false
fmt.Println(isTrue)
fmt.Println(isFalse)
fmt.Println("字符串类型（String Type）")
str1 := "Hello, "
str2 := "Go!"
concatenated := str1 + str2
fmt.Println(concatenated)
fmt.Println("切片类型（Slice Types）")
numbers := []int{1, 2, 3, 4, 5}
fmt.Println(numbers)
// 修改切片元素
numbers[0] = 10
fmt.Println(numbers)
// 切片操作
subSlice := numbers[1:4]
fmt.Println(subSlice)
fmt.Println("映射类型（Map Types）")
ages := map[string]int{
"Alice": 25,
"Bob": 30,
"Eve": 28,
}
fmt.Println(ages)
fmt.Println("Alice's age:", ages["Alice"])
// 添加新的键值对
ages["Charlie"] = 22
fmt.Println(ages)
fmt.Println("结构体类型（Struct Types）")
person := Person{
FirstName: "John",
LastName: "Doe",
Age: 30,
}
fmt.Println(person)
fmt.Println("Name:", person.FirstName, person.LastName)
fmt.Println("接口类型（Interface Types）")
var shape Shape
circle := Circle{Radius: 5}
shape = circle
fmt.Println("Circle Area:", shape.Area())
fmt.Println("函数类型（Function Types）")
var op Operation
op = add
result := op(10, 5)
fmt.Println("Addition:", result)
op = subtract
result = op(10, 5)
fmt.Println("Subtraction:", result)
fmt.Println("通道类型（Channel Types）")
messages := make(chan string)
go func() {
messages <- "Hello, Go!"
}()
msg := <-messages
fmt.Println(msg)
fmt.Println("指针类型（Pointer Types）")
x = 10
var ptr *int
ptr = &x
fmt.Println("Value of x:", x)
fmt.Println("Value stored in pointer:", *ptr)
*ptr = 20
fmt.Println("Updated value of x:", x)
}
下面逐个解释代码中涉及的知识点：
-
type Person struct { ... }: 定义了一个结构体类型Person，表示一个人的信息，包括FirstName、LastName和Age字段。 -
type Shape interface { ... }: 定义了一个接口类型Shape，该接口要求实现一个方法Area()返回一个float64类型。 -
type Circle struct { ... }: 定义了一个结构体类型Circle，表示一个圆的半径。func (c Circle) Area() float64 { ... }：为Circle类型实现了Shape接口的Area()方法，用于计算圆的面积。 -
func add(a, b int) int { ... }: 定义了一个函数add，用于执行整数相加操作。 -
func subtract(a, b int) int { ... }: 定义了一个函数subtract，用于执行整数相减操作。 -
type Operation func(int, int) int: 定义了一个函数类型Operation，它接受两个整数参数并返回一个整数结果。 -
main() { ... }: 程序的入口函数。
- 定义了多种不同类型的变量，包括整数、浮点数、布尔、字符串、切片、映射、结构体、接口、函数、通道和指针类型。
- 演示了不同类型变量的初始化、赋值、访问以及基本操作。
- 使用切片操作提取部分切片。
- 演示了映射的使用，包括添加新的键值对和访问键值对。
- 演示了结构体的定义和初始化，并访问结构体字段。
- 展示了接口的使用，将
Circle类型赋值给Shape类型变量，并调用接口方法。 - 演示了函数类型的定义和使用，将不同函数赋值给
Operation类型变量，并进行调用。 - 使用通道来实现并发通信，通过匿名函数在 goroutine 中发送和接收消息。
- 演示了指针的使用，包括创建指针变量、通过指针修改变量的值等操作。
Go语言中类型转换说明
Go语言支持类型转换，但需要注意一些规则和限制。类型转换用于将一个数据类型的值转换为另一个数据类型，以便在不同的上下文中使用。以下是有关Go语言中类型转换的一些重要信息：
-
基本类型之间的转换： 可以在基本数据类型之间进行转换，但是必须注意类型的兼容性和可能导致的数据丢失。例如，从
int到float64的转换是安全的，但从float64到int可能导致小数部分被截断。 -
显示类型转换： 在Go中，使用强制类型转换来显式指定将一个值转换为另一个类型。语法是：
destinationType(expression)。例如：float64(10)。 -
非兼容类型之间的转换： 对于不兼容的类型，编译器不会自动进行转换。例如，不能直接将一个
string类型转换为int类型。 -
类型别名的转换： 如果有类型别名（Type Alias），在转换时需要注意使用别名的兼容性。
以下是一些示例来展示类型转换：
package main
import "fmt"
func main() {
// 显式类型转换
var x int = 10
var y float64 = float64(x)
fmt.Println(y)
// 类型别名的转换
type Celsius float64
type Fahrenheit float64
c := Celsius(25)
f := Fahrenheit(c*9/5 + 32)
fmt.Println(f)
}