【GO】《GO HANDBOOK》读书笔记

Go

引言

非常入门的一本书？准确来说是一篇GO的入门文章，用于学学英语和简单了解GO还不错，并且词汇和语法都比较简洁易懂。

话不多说，下面就来看看这篇文章的翻译。

原文

https://www.freecodecamp.org/news/go-beginners-handbook/

1.介绍GO

它是由谷歌工程师创建的，设计这门语言的主要目标是：

• 提高项目的编译和运行速度
• 入门门槛足够低，但是也要避免过于简单和低级。
• 具备可移植（编译后的 Go 程序是二进制文件，不需要其他文件就能运行，而且是跨平台的，因此可以很容易地分发）
• 单调、稳定、可预测，犯错的机会少 。
• 能充分发挥多线程优势

2.如何开始？

在深入了解该语言的具体内容之前，您应该了解以下几件事。

首先，https://go.dev 是该语言的主页。

下面是首选的入门资源：

• 从 https://go.dev/doc/install 下载 Go 二进制文件（go 命令和其他相关工具）。
• 参考 Go 官方文档： https://go.dev/doc/
• 查看所有 Go 软件包： https://pkg.go.dev/
• 访问 Go Playground： https://go.dev/play/
• ...

3.安装 GO

安装GO的教程网上一抓一大把，个人使用的是Window环境，Windows 环境下只需要安装exe应用程序即可，简单无脑就不演示了。

4.开发 IDE 安装和配置

NOTE: you might have to open a new terminal before you can run the program, as the installer added the Go binaries folder to the path.

注意：由于安装程序在路径中添加了 Go 二进制文件夹，运行程序前可能需要打开一个新的终端。

在使用IDE之前，请先确保自己的环境变量可以正常使用GO。

本书使用的是 VS Code，具体可以阅读此网站了解：Go with Visual Studio Code。

[[【Go】Go in Visual Studio Code]]

VS Code安装之后，需要安装GO相关的扩展：marketplace.visualstudio.com/items?itemName=golang.go

5.你好，世界

1. 创建一个新的文件夹，比如下面的 hello。

2. 创建一个hello.go的文件，并且在文件内写入下面的内容：

package main 

import "fmt" 

func main() { 
    fmt.Println(" Hello, World!") 
}

3. 在文件所在路径，运行go run hello.go，如果结果如下说明运行成功：

xander@LAPTOP-47J243NL MINGW64 /e/adongstack/go/hello

$ go run hello.go
 Hello, World!

下面来解释下上面的入门程序：

1. 每个 .go 文件首先声明它是哪个软件包的一部分
2. 一个软件包可以由多个文件组成，也可以只由一个文件组成。一个程序可以包含多个软件包。
3. main函数是程序的入口点，也是可执行程序的标识。
4. 我们使用 import 关键字来导入程序包。

fmt is a built-in package provided by Go that provides input/ output utility functions.

fmt 是 Go 提供的一个内置包，提供输入/输出实用功能。

GO官方拥有庞大的标准库，从网络连接到数学、密码、图像处理、文件系统访问等，我们都可以使用它。

Standard library - Go Packages

比如，有关fmt 这个包的文档介绍可以查看这个地址了解：fmt package - fmt - Go Packages，根据文档，该函数功能是 "根据格式说明符进行格式化，并写入标准输出"。

我们使用 "点 "语法 fmt.Println()来指定该函数由该程序包提供。

当代码执行完主函数后，就没有其他事情可做了，执行结束。

在main函数中，我们定义了fmt.Println(" Hello, World!") 这样一串代码。

6.编译并运行 Go 程序

本部分接着上一章节的入门程序介绍，解释如何编译并且运行go程序

go run hello.go

go run 工具首先编译，然后运行指定的程序。

我们可以使用 go build 创建二进制文件：

go build hello.go

个人电脑上执行的结果如下：

PS E:\adongstack\go\hello> go build .\hello.go
PS E:\adongstack\go\hello> dir


    目录: E:\adongstack\go\hello


Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a----         2023/9/19     13:33        1897472 hello.exe
-a----         2023/9/19     13:32             84 hello.go

Go 是可移植的，因为本质编译之后本质就是二进制文件，这样每个人都可以按原样运行程序，并且二进制文件已经打包供执行。

程序将在我们构建它的相同架构上运行。

我们可以使用 GOOS 和 GOARCH 环境变量为不同的架构创建不同的二进制文件：

GOOS = windows GOARCH = amd64 go build hello.go

这将为 64 位 Windows 机器创建一个 hello.exe 可执行文件：

64 位 macOS（英特尔或苹果）的设置为

GOOS = darwin GOARCH = amd64

Linux 为 :

GOOS = linux GOARCH = amd64

这是 Go 的最佳功能之一。

7.工作空间

Go有一个特别之处就是我们所说的工作空间。

工作区是 Go 的 "大本营"。

默认情况下，Go 会选择 $ HOME/ go 路径，因此你会在主目录中看到一个 go 文件夹。

例如，当我在 VS Code 中加载 hello.go 文件时，它提示我安装 gopls 命令、Delve 调试器 (dlv) 和 staticcheck linter。

它们已自动安装在 $ HOME/ go 下：

当你使用 go install 安装软件包时，它们将被存储在这里。

这就是我们所说的 GOPATH。

你可以更改 GOPATH 环境变量来改变 Go 安装包的位置。

当你同时在不同的项目中工作，并希望隔离你使用的库时，这一点非常有用。

8.深入语言

既然我们已经有了初步的概念，并运行了第一个 Hello, World! 程序，那么我们就可以深入研究这门语言了。

这种语言没有语义上重要的空白。

就像 C、C + +、Rust、Java 和 JavaScript。与 Python 不同的是，Python 的空白是有意义的，它被用来创建块而不是大括号。

Go 非常重视缩进和视觉顺序。安装 Go 时，我们还可以使用 gofmt 命令行工具来格式化 Go 程序。

VS Code 在引擎盖下使用该工具来格式化 Go 源文件。

这是一个非常有意思的特性，语言创建者定义了规则，每个人都会使用这些规则。

这非常适合大型团队的项目。

本书建议在VS Code 当中设置 “Format on Save” 以及 “Format on Paste”:

Go 中的注释使用常见的 C / C + + / JavaScript / Java 语法：

9.变量

在 GO 里面可以是用 var关键字定义变量：

var age = 20

var 关键字可以定义包级别变量：

package main 

import "fmt" 

var age = 20 

func main() { 
    fmt.Println(" Hello, World!") 
}

或者定义在函数内部：

package main 

import "fmt" 



func main() { 

    var age = 20 
    
    fmt.Println(" Hello, World!") 
}

在软件包级别定义的变量在组成软件包的所有文件中都是可见的。

一个软件包可以由多个文件组成，只需创建另一个文件，并在顶部使用相同的软件包名称即可。

在函数内部定义的变量，一个变量只能在函数中可见。

这使得 Go 判断变量 age 的类型是 int。

我们稍后会看到更多关于类型的内容，但你应该知道有许多不同的类型，首先是 int、string 和 bool。

我们也可以声明一个没有现存值的变量，但在这种情况下，我们必须像这样设置类型：

var age int 
var name string 
var done bool

当您知道变量值时，通常使用带有 := 操作符的短变量声明：

age := 10 
name := "Roger"

注意变量名称是区分大小写的，如果名称较长，通常使用驼峰字母大写，因此我们使用 carName 来表示汽车的名称。

您可以使用赋值运算符 = 为变量赋值。

var age int 
age = 10 
age = 11

如果一个变量确定不会改变，可以使用const关键字定义：

const age = 10

你可以在一行定义多个变量：

var age, name = 10, "Roger" 

// or 

age, name := 10, "Roger"

如果定义了变量但是没有使用，在VS Code 中会有相关提示。

这些错误信息实际是编译

如果您声明一个变量，但没有将其初始化为一个值，那么它会自动分配一个值，这个值取决于变量的类型，例如整数为 0，字符串为空字符串。

10.基本类型

Go 的基本类型有

• 整数（int、int8、int16、int32、rune、int64、uint、uintptr、uint8、uint16、uint64）
• 浮点数（float32、float64），用于表示小数
• 复数类型（complex64、complex128），用于数学运算
• 字节（byte），表示单个 ASCII 字符
• 字符串（string），一组字节
• 布尔类型（bool），表示真或假

我们有很多不同的类型来表示interger，大部分时间你都会使用int，你可能会选择一个更专业的类型来进行优化（刚开始学习时不需要考虑这些）。

int 类型针对 32位机器和64位的机器做了类型适配，

uint 是一个无符号的 int，如果知道数值不会是负数，就可以用它来加倍存储数值。

11.字符串

Strings 在 Go 语言中是一串字节数组。

我们可以使用下面的语法定义一串字符串：

var name = "test"

值得注意的是，与其他语言不同，字符串的定义只能使用双引号，而不能使用单引号（比如 JS）。

可以使用len 函数获取字符串长度

len( name) // 4

您可以使用方括号访问单个字符，同时传递您要获取的字符的索引：

name[ 0] //" t" (indexes start at 0) 
name[ 1] //" e"

可以使用下面的语法像Python语言一样对于字符串进行“切片”：

name[ 0: 2] //" te" 
name[: 2] //" te" 
name[ 2:] //" st"

使用下面的语法可以拷贝一个字符串：

var newstring = name[:]

您可以将一个字符串赋值给一个新变量：

var first = "test" 
var second = first

Strings 是不可变变量，意味着你不能更新一个Strings，即使使用赋值运算符为第一项赋值，第二项的值仍然是 "test"：

var first = "test" 

var second = first 

first = "another test" 

first //" another test" 
second //" test"

字符串是引用类型，这意味着如果将字符串传递给函数，复制的将是字符串的引用，而不是其值。

但由于字符串是不可变的，在这种情况下，与传递 int 等类型的字符串在实际操作中并无太大区别。

可以使用 + 运算符连接两个字符串：

var first = "first" 

var second = "second" 

var word = first + " " + second //" first second"

Go 在字符串包中提供了多个字符串实用程序。

我们已经在 "Hello, World!"示例中看到了如何导入包，下面介绍如何导入字符串：

以下是导入字符串的方法：

package main 

import ( "strings" )

12.数组

数组是由单一类型的项目组成的序列。

我们这样定义一个数组：

var myArray [3] string // 包含 3 个字符串的数组

你可以使用以下值初始化数组：

var myArray = [3] string{" First", "Second", "Third"}

在这种情况下，你也可以让 Go 来帮你计数：

var myArray = [...] string{" First", "Second", "Third"} 

注意，数组只能包含相同类型的值。

数组不能调整大小，必须在 Go 中明确定义数组的长度。

数组不能调整大小，必须在 Go 中明确定义数组的长度。

这是数组类型的一部分。此外，也不能使用变量来设置数组的长度。

由于这种限制，在 Go 中很少直接使用数组，而是使用 Slice（稍后会详细介绍）。

注意 Slice 底层也是数组实现的，所以了解数组是基础。

数组可以通过方括号加下标值获取数组特定位置，然后针对特定位置设置新值。

myArray[ 0] // indexes start at 0 

myArray[ 1]

数组也可以使用len() 函数获取数组长度：

数组是值类型。这意味着可以复制数组：

anotherArray := myArray

将数组传递给函数，或从函数中返回数组，都会创建原始数组的副本。

这与其他编程语言不同。

让我们举一个简单的例子，在复制一个数组项后，给它赋一个新值。

请看，拷贝并没有改变：

var myArray = [3] string{" First", "Second", "Third"} 

myArrayCopy := myArray 

myArray[ 2] = "Another" 

myArray[ 2] //" Another"
myArrayCopy[ 2] //" Third"

请记住，你只能在数组中添加单一类型的项，因此设置 myArray[ 2] = 2 会引发错误。

底层元素在内存中连续存储。

低级元素持续存储在内存中。

13.分片

分片是一种类似于数组的数据结构，但它的大小可以改变。

切片使用数组，是建立在数组之上的一种抽象结构，它使切片更灵活、更有用（将数组视为低级结构）。

如果你知道需要对切片执行操作，你可以要求它拥有比最初需要的更大容量，这样当你需要更多空间时，空间就会随时可用（而不是找到切片并将其移动到一个有更多空间的新内存位置，然后通过垃圾回收处理旧位置）。

我们可以为 make() 添加第三个参数来指定容量：

newSlice := make([] string, 0, 10) // an empty slice with capacity 10

多个切片可以使用同一个数组作为底层数组：

myArray := [3] string{" First", "Second", "Third"} mySlice = myArray[:]

与字符串一样，使用该语法可以获取片段的一部分：

mySlice := [] string{" First", "Second", "Third"} newSlice := mySlice[: 2] // get the first 2 items newSlice2 := mySlice[ 2:] // ignore the first 2 items newSlice3 := mySlice[ 1: 3] // new slice with items in position 1-2

14.Maps

map 是go语言的常用数据类型。

agesMap := make( map[ string] int)

您无需设置地图可容纳的物品数量。您可以通过这种方式向map添加新内容：

agesMap[" flavio"] = 39

您也可以使用以下语法直接用值初始化映射：

agesMap := map[ string] int{" flavio": 39}

通过下面的语法可以获取map的key的值：

age := agesMap[" flavio"]

使用delete() 函数可以删除Map中对应的Key。

delete( agesMap, "flavio")

15.循环

Go 的循环语句关键字也是for:

for i := 0; i < 10; i + + { 

    fmt.Println( i) 
}

我们首先初始化一个循环变量，然后设置每次迭代时要检查的条件，以决定循环是否应该结束，最后在每次迭代结束时执行 post 语句，在本例中，该语句会递增 i。

i++ 使 i 变量递增。

< 操作符用于将 i 与数字 10 进行比较，并返回 true 或 false，以决定是否执行循环体。

与 C 或 JavaScript 等其他语言不同，我们不需要在该代码块周围使用括号。

此外还需要注意，Go 没有 while这样的循环语法，如果想要实现类似的功能，可以使用for进行模拟。

i := 0 for i < 10 { 

    fmt.Println( i) i + + 
    
}

此外可以通过break语句跳出循环。

for { 
    fmt.Println( i) 
     
     if i < 10 { 
         break 
     } 
     i ++ 
}

我在循环体中使用了 if 语句，但我们还没有看到条件！我们下一步再做。

现在我要介绍的是范围。

我们可以使用 for 语法遍历数组：

numbers := [] int{ 1, 2, 3} 

for i, num := range numbers { 
    fmt.Printf("% d: %d\ n", i, num) 
} 

// 0: 1 

// 1: 2 

// 2: 3

注：我使用了 fmt.Printf()，它允许我们使用表示十进制整数的 %d 和表示添加行结束符的 \n 来向终端打印任何值。

当不需要使用index时，使用这种语法很常见：

for _, num := range numbers { 
    //... 
}

使用表示 "忽略这个 "的特殊 _ 字符，以避免 Go 编译器出现 "你没有使用 i 变量！"的错误。

16.条件式

条件语句的语法和其他语言类似：

if age < 12 { // child 
} else if age < 18 { 
// teen 

} else { 

// adult 

}

和其他语言一样，在if或者else代码块中定义变量，变量的可见范围等同于代码块的范围。

如果要使用多个不同的 if 语句来检查一个条件，最好使用 switch：

switch age 
{ 
case 0: fmt.Println(" Zero years old") 
case 1: fmt.Println(" One year old") 
case 2: fmt.Println(" Two years old") 
case 3: fmt.Println(" Three years old") 
case 4: fmt.Println(" Four years old") 
default: fmt.Println( i + " years old") 
}

与 C、JavaScript 和其他语言相比，您不需要在每种情况后都有一个分隔符。

17.操作符

到目前为止，我们在代码示例中使用了一些运算符，如 =、:= 和 <。

我们使用赋值运算符 = 和 := 来声明和初始化变量：

var a = 1 

b := 1

我们有比较运算符 == 和 != ，它们接受 2 个参数并返回布尔值。

var num = 1 

num == 1 // true 
num != 1 // false

当然还有下面的内容：

var num = 1 

num > 1 // false 
num >= 1 // true 
num < 1 // false 
num <= 1 // true

我们有二进制（需要两个参数）算术运算符，如 + - * / %。

1 + 1 // 2 
1 - 1 // 0 
1 * 2 // 2 
2 / 2 // 1 
2 % 2 // 0

+ 运算符可以连接字符串：

"a" + "b" //" ab"

我们有一元运算符 ++ 和 -- 来递增或递减数字：

var num = 1 
num++ // num == 2 
num-- // num == 1

请注意，与 C 或 JavaScript 不同的是，我们不能像 ++num 那样将它们前置到数字上。

此外，该操作不会返回任何值。

我们有布尔运算符帮助我们根据真假值做出决定：&&、|| 和 !：

true && true // true 
true && false // false 
true || false // true 
false || false // false 
!true // false 
!false // true

18.结构

结构体是一种包含一个或多个变量的类型。它就像是变量的集合。我们称之为字段。它们可以有不同的类型。

下面是定义结构体的代码：

type Person struct { 
    Name string 
    Age int 
}

请注意，我使用了大写字母作为字段名称，否则这些字段将成为软件包的私有字段，当您将结构体传递给另一个软件包提供的函数（如我们用于处理 JSON 或数据库的函数）时，就无法访问这些字段。

定义结构体后，我们就可以用该类型初始化变量：

flavio := Person{" Flavio", 39}

可以使用下面的方式获取结构体的字段数据：

flavio.Age // 39 

flavio.Name //" Flavio"

结构体非常有用，因为它可以将不相关的数据分组，并将其传递给函数或从函数中传递出来，还可以存储在片段中，等等。

一旦定义，结构体就是一种类似 int 或字符串的类型，这意味着你也可以在其他结构体内部使用它：

type FullName struct { 

FirstName string 
LastName string 

} 

type Person struct { 

Name FullName 
Age int 

}

19.Functions

函数是一个代码块，它被赋予一个名称，并包含一些指令。

在 "你好，世界！"示例中，我们创建了一个 main 函数，它是程序的入口。

package main import "fmt" func main() { fmt.Println(" Hello, World!") }

通常，我们用自定义名称定义函数：

func doSomething() { 

然后通过下面的方式调用函数：

doSomething()

函数可以接受参数，我们必须这样设置参数的类型：

func doSomething( a int, b int) { 

} 

doSomething( 1, 2)

a 和 b 是函数内部参数的名称。

函数可以返回一个值，就像下面这样：

func sumTwoNumbers( a int, b int) int {

    return a + b 

} 

result := sumTwoNumbers( 1, 2)

请注意，这里指定了返回值类型

GO 语言的return 可以返回超过一个值：

func performOperations( a int, b int) (int, int) { 
    return a + b, a - b 
} 

sum, diff := performOperations( 1, 2)

这很有趣，因为许多语言只允许一个返回值。函数内部定义的任何变量都是函数的局部变量。

函数也可以接受数量不限的参数，在这种情况下，我们称之为变量函数：

func sumNumbers( numbers ... int) int { 
    sum := 0 
    for _, number := range numbers 
    { 
        sum + = number 
    } 
    return sum 
} 

total := sumNumbers( 1, 2, 3, 4)

20.指针

GO语言支持使用指针，假设使用下面的变量定义：

age := 20

有了变量指针后，就可以使用 * 运算符获取其指向的值：

age := 20 
ageptr = &age 
agevalue = *ageptr

这在调用函数并将变量作为参数传递时非常有用。

Go 默认将变量值复制到函数内部，因此不会改变 age 的值：

func increment(a int) { 

    a = a + 1 
                      
} 

func main() { 
    age := 20 
    increment(age) // age is still 20 
    
}

为此，您可以使用指针：

func increment( a *int) { 
    
    *a = *a + 1
    
} 

func main() { 

age := 20 
             
 increment(& age) // age is now 21 
 
 }

21.函数

一个函数可以分配给一个结构体，在这种情况下，我们称之为方法。

type Person struct { 

    Name string Age int 
    
} 

func (p Person) Speak() { 

    fmt.Println(" Hello from " + p.Name) 
    
} 


func main() { 

    flavio := Person{ 
        Age: 39, 
        Name: "Flavio"
    } 
    
    flavio.Speak() 

}

方法参数可以指定指针类型或者值类型，这将是一个指针接收器，用于接收指向结构实例的指针：

func (p *Person) Speak() { fmt.Println(" Hello from " + p.Name) }

22.接口

接口是一种定义了一个或多个方法签名的类型。方法没有实现，只有签名：名称、参数类型和返回值类型。类似于这样：

type Speaker interface { Speak() }

现在，你可以让函数接受任何类型，并实现接口定义的所有方法：

func SaySomething( s Speaker) { 
    s.Speak() 
}

我们可以将实现这些方法的任何结构传递给它：

type Speaker interface { 
    Speak() 
    
} 

type Person struct { 
    Name string Age int 
} 

func (p Person) Speak() { 
    fmt.Println(" Hello from " + p.Name) 
} 

func SaySomething( s Speaker) { 
    s.Speak() 
}

func main() { 

    flavio := Person{ Age: 39, Name: "Flavio"} 
    SaySomething( flavio) 
}

23. 下一步行动

本手册介绍 Go 编程语言。除了这些基础知识，现在还有很多东西需要学习。

垃圾回收、错误处理、并发和网络、文件系统 API 等等。学习无止境。

我的建议是，选择一个你想构建的程序，然后开始学习你需要的东西。这会很有趣，也很有收获。

相关

【Linux】《The Command Line Handbook》 读书笔记（上半部分）
【Linux】《The Command Line Handbook》 读书笔记（下半部分）