Go语言学习笔记（三）

教程：文档 - Go 编程语言 (studygolang.com)

调用模块代码

在call-module-code需要注意，需要在hello目录下操作

go mod edit -replace example.com/greetings=../greetings

这是一个在Go项目的模块管理中的命令。在Go的模块管理工具（go mod）中，这个命令用于修改模块依赖关系。

具体来说，go mod edit -replace example.com/greetings=../greetings 这个命令的作用是：

1. -replace: 这个选项表示你要替换一个已经存在的依赖。
2. example.com/greetings: 这是你要替换的依赖的原始路径。
3. ../greetings: 这是你要替换成的新路径。

所以，这个命令的意思是：将example.com/greetings这个依赖替换为项目根目录下的greetings目录。

简单来说，这个命令用于将一个远程依赖替换为本地路径的依赖。这在你想要使用本地版本的库而不是远程版本时非常有用，例如在开发过程中。

go mod tidy

go mod tidy 是一个 Go 语言的命令，用于自动添加或删除不必要的模块依赖项，使 go.mod 文件保持最新。

当你使用 Go 语言开发一个项目时，可能会使用 go get 命令来获取外部的依赖库。这些库会被添加到项目的 go.mod 文件中。随着时间的推移，有些依赖可能不再需要，或者新的依赖可能被添加进来。为了保持 go.mod 文件的整洁和一致性，你可以使用 go mod tidy 命令来自动处理这些不必要的依赖。

具体来说，go mod tidy 会做以下几件事：

1. 删除不必要的依赖 ：如果一个依赖在代码中没有被使用，或者其版本与 go.mod 文件中指定的版本不匹配，那么这个依赖会被从 go.mod 文件中移除。
2. 添加缺失的依赖 ：如果代码中使用了某个外部库，但这个库还没有被添加到 go.mod 文件中，那么 go mod tidy 会自动将其添加进来。
3. 更新依赖的版本 ：如果某个依赖有新版本可用，并且这个新版本与 go.mod 文件中指定的版本不匹配，那么 go mod tidy 会自动更新这个依赖的版本。

总之，go mod tidy 是一个非常有用的命令，可以帮助开发者自动管理项目的模块依赖，确保 go.mod 文件始终是最新的。

操作后hello文件夹下go.mod内容为

如果不操作，则报错hello.go:6:2: no required module provides package example.com/greetings; to add it:

go get example.com/greetings

处理错误

package greetings

import (
	"errors"
	"fmt"
)

// Hello returns a greeting for the named person.
func Hello(name string) (string, error) {
	if name == "" {
		return "", errors.New("empty name")
	}
	// Return a greeting that embeds the name in a message.
	message := fmt.Sprintf("Hi, %v. Welcome!", name)
	return message, nil
}

package main

import (
	"fmt"
	"log"

	"example.com/greetings"
)

func main() {
	// Get a greeting message and print it.
	message, err := greetings.Hello("")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(message)
}

使用日志

package main

import (
	"fmt"
	"log"

	"example.com/greetings"
)

func main() {
	log.SetPrefix("greetings: ")
	log.SetFlags(0)
	// Get a greeting message and print it.
	message, err := greetings.Hello("")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(message)
}

返回随机问候语

package main

import (
	"errors"
	"fmt"
	"log"
	"math/rand"
	// "example.com/greetings"
)

func Hello(name string) (string, error) {
	if name == "" {
		return name, errors.New("Empty name")
	}
	message := fmt.Sprintf(randomFormat(), name)
	return message, nil
}
func randomFormat() string {
	stringArray := []string{"Hi, %v. Welcome!",
		"Great to see you, %v!",
		"Hail, %v! Well met!"}
	index := rand.Intn(len(stringArray))
	return stringArray[index]
}
func main() {

	message, err := Hello("小明")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(message)
}

向多人问候

package greetings

import (
	"errors"
	"fmt"
	"math/rand"
)

func Hello(name string) (string, error) {
	if name == "" {
		return name, errors.New("Empty name")
	}
	message := fmt.Sprintf(randomFormat(), name)
	return message, nil
}
func randomFormat() string {
	stringArray := []string{"Hi, %v. Welcome!",
		"Great to see you, %v!",
		"Hail, %v! Well met!"}
	index := rand.Intn(len(stringArray))
	return stringArray[index]
}
func Hellos(names []string) (map[string]string, error) {
	cMap := make(map[string]string)
	for _, value := range names {
		message, err := Hello(value)
		if err != nil {
			return nil, err
		}
		cMap[value] = message
	}
	return cMap, nil

}

知识点：

1、函数入参为数组怎么写。

2、函数返回值为map怎么写

3、如何创建一个map make(map[string]string)

package main

import (
	"fmt"
	"log"

	"example.com/greetings"
	// "example.com/greetings"
)

func main() {
	names := []string{
		"小明",
		"小王",
	}
	message, err := greetings.Hellos(names)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(message)
}

添加单元测试

package greetings

import (
	"regexp"
	"testing"
)

func TestHelloName(t *testing.T) {
	name := "Gladys"
	want := regexp.MustCompile(`\b` + name + `\b`)
	msg, err := Hello("Gladys")
	if !want.MatchString(msg) || err != nil {
		t.Fatalf(`Hello("Gladys")=%q,%v,want match for %#q,nil`, msg, err, want)

	}

}
func TestHelloEmpty(t *testing.T) {
	msg, err := Hello("")
	if msg != "" || err == nil {
		t.Fatalf(`Hello("") = %q, %v, want "", error`, msg, err)
	}

}

名为TestHelloName的测试函数，它接受一个类型为*testing.T的参数t。这是Go语言中用于编写测试的标准方式。

TestHelloName方法若msg中不存在name或者err不为nil，则用例失败，

在vscode中，可以在测试函数前点击运行按钮运行，也可以在命令行运行go test或者 go test -v

编译和安装应用程序

代码编译为可执行文件，生成hello.exe

go build

命令行下运行hello.exe

安装软件包

go install

A Tour of Go

这个tour教程不错。

左边为教程，右边为实例

指针

Go 拥有指针。指针保存了值的内存地址。

类型 *T 是指向 T 类型值的指针。其零值为 nil。

var p *int

& 操作符会生成一个指向其操作数的指针。

i := 42
p = &i

* 操作符表示指针指向的底层值。

fmt.Println(*p) // 通过指针 p 读取 i
*p = 21         // 通过指针 p 设置 i

这也就是通常所说的"间接引用"或"重定向"。

与 C 不同，Go 没有指针运算。

package main

import "fmt"

func main() {
	i, j := 42, 2701

	p := &i         // 指向 i
  fmt.Println(p)
	fmt.Println(*p) // 通过指针读取 i 的值
	*p = 21         // 通过指针设置 i 的值
	fmt.Println(i)  // 查看 i 的值

	p = &j         // 指向 j
	*p = *p / 37   // 通过指针对 j 进行除法运算
	fmt.Println(j) // 查看 j 的值
}

结构体

一个结构体（struct）就是一组字段（field）。

package main

import "fmt"

type Vertex struct {
	X int
	Y int
}

func main() {
	fmt.Println(Vertex{1, 2})
}

结构体字段

结构体字段使用点号来访问。

package main

import "fmt"

type Vertex struct {
	X int
	Y int
}

func main() {
	v := Vertex{1, 2}
	v.X = 4
	fmt.Println(v.X)
}

结构体指针

结构体字段可以通过结构体指针来访问。

如果我们有一个指向结构体的指针 p，那么可以通过 (*p).X 来访问其字段 X。不过这么写太啰嗦了，所以语言也允许我们使用隐式间接引用，直接写 p.X 就可以。

package main

import "fmt"

type Vertex struct {
	X int
	Y int
}

func main() {
	v := Vertex{1, 2}
	p := &v
	p.X = 1e9 //赋值 或者 (*p).X = 1e9 两种写法一样
	fmt.Println(v)
}

输出

{1000000000 2}

结构体文法

结构体文法通过直接列出字段的值来新分配一个结构体。

使用 Name: 语法可以仅列出部分字段。（字段名的顺序无关。）

特殊的前缀 & 返回一个指向结构体的指针。

package main

import "fmt"

type Vertex struct {
	X, Y int
}

var (
	v1 = Vertex{1, 2}  // 创建一个 Vertex 类型的结构体
	v2 = Vertex{X: 1}  // Y:0 被隐式地赋予
	v3 = Vertex{}      // X:0 Y:0
	p  = &Vertex{1, 2} // 创建一个 *Vertex 类型的结构体（指针）
)

func main() {
	fmt.Println(v1, p, v2, v3)
}

数组

类型 [n]T 表示拥有 n 个 T 类型的值的数组。

表达式

var a [10]int

会将变量 a 声明为拥有 10 个整数的数组。

数组的长度是其类型的一部分，因此数组不能改变大小。这看起来是个限制，不过没关系，Go 提供了更加便利的方式来使用数组。

package main

import "fmt"

func main() {
	var a [2]string
	a[0] = "Hello"
	a[1] = "World"
	fmt.Println(a[0], a[1])
	fmt.Println(a)

	primes := [6]int{2, 3, 5, 7, 11, 13}
	fmt.Println(primes)
}

切片

每个数组的大小都是固定的。而切片则为数组元素提供动态大小的、灵活的视角。在实践中，切片比数组更常用。

类型 []T 表示一个元素类型为 T 的切片。

切片通过两个下标来界定，即一个上界和一个下界，二者以冒号分隔：

a[low : high]

它会选择一个半开区间，包括第一个元素，但排除最后一个元素。

以下表达式创建了一个切片，它包含 a 中下标从 1 到 3 的元素：

a[1:4]

package main

import "fmt"

func main() {
	primes := [6]int{2, 3, 5, 7, 11, 13}

	var s []int = primes[1:4]
	fmt.Println(s)
}

切片就像数组的引用

切片并不存储任何数据，它只是描述了底层数组中的一段。

更改切片的元素会修改其底层数组中对应的元素。

与它共享底层数组的切片都会观测到这些修改。

package main

import "fmt"

func main() {
	names := [4]string{
		"John",
		"Paul",
		"George",
		"Ringo",
	}
	fmt.Println(names)

	a := names[0:2]
	b := names[1:3]
	fmt.Println(a, b)

	b[0] = "XXX"
	fmt.Println(a, b)
	fmt.Println(names)
}

修改b的第一个值，切片a和数组中该值都被更改。

切片文法

切片文法类似于没有长度的数组文法。

这是一个数组文法：

[3]bool{true, true, false}

下面这样则会创建一个和上面相同的数组，然后构建一个引用了它的切片：

[]bool{true, true, false}

package main

import "fmt"

func main() {
	q := []int{2, 3, 5, 7, 11, 13}
	fmt.Println(q)

	r := []bool{true, false, true, true, false, true}
	fmt.Println(r)

	s := []struct {
		i int
		b bool
	}{
		{2, true},
		{3, false},
		{5, true},
		{7, true},
		{11, false},
		{13, true},
	}
	fmt.Println(s)
}

切片的默认行为

在进行切片时，你可以利用它的默认行为来忽略上下界。

切片下界的默认值为 0，上界则是该切片的长度。

对于数组

var a [10]int

来说，以下切片是等价的：

a[0:10]
a[:10]
a[0:]
a[:]

package main

import "fmt"

func main() {
	s := []int{2, 3, 5, 7, 11, 13}

	s = s[1:4]
	fmt.Println(s)

	s = s[:2]
	fmt.Println(s)

	s = s[1:]
	fmt.Println(s)
}

切片的长度与容量

切片拥有 长度 和 容量。

切片的长度就是它所包含的元素个数。

切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。

切片 s 的长度和容量可通过表达式 len(s) 和 cap(s) 来获取。

你可以通过重新切片来扩展一个切片，给它提供足够的容量。试着修改示例程序中的切片操作，向外扩展它的容量，看看会发生什么。

package main

import "fmt"

func main() {
	s := []int{2, 3, 5, 7, 11, 13}
	printSlice(s)

	// 截取切片使其长度为 0
	s = s[:0]
	printSlice(s)

	// 拓展其长度
	s = s[:4]
	printSlice(s)

	// 舍弃前两个值
	s = s[2:]
	printSlice(s)
}

func printSlice(s []int) {
	fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}

len=6 cap=6 [2 3 5 7 11 13]
len=0 cap=6 []
len=4 cap=6 [2 3 5 7]
len=2 cap=4 [5 7]

nil 切片

切片的零值是 nil。

nil 切片的长度和容量为 0 且没有底层数组。

package main

import "fmt"

func main() {
	var s []int
	fmt.Println(s, len(s), cap(s))
	if s == nil {
		fmt.Println("nil!")
	}
}

[] 0 0
nil!

Go 语言之旅 (go-zh.org)