打包和工具链

包

包命名

main包

导入

1. 查找Go安装目录的src/pkg下的包

2. 查找第一个GOPATH中的环境变量路径下的src目录下的包

3. 查找第二个GOPATH中的环境变量路径下的src目录下的包

4. …

远程导入

命名导入

import (
	"fmt"
	myfmt "mylib/fmt"
)

函数init

数组, 切片和映射

数组

声明和初始化

1. 声明一个数组, 并设置为零值

var array [5]int

1. 使用数组字面量声明数组

array := [5]int{10, 20, 30, 40, 50}

1. 自动计算声明数组的长度

array := [...]int{10, 20, 30, 40, 50}

1. 声明数组并指定特定元素值

array := [5]{1: 10, 2: 20}

1. 访问指针数组的元素

array := [5]*int{0: new(int), 1: new(int)}
*array[0] = 10
*array[1] = 20

1. 多维数组

array := [4][2]int{{10, 11}, {20, 21}, {30, 31}, {40, 41}}
// 声明单个元素
array := [4][2]int{1: { 0: 20 }, 3: { 1: 40 }}

切片

1. 使用长度声明切片

slice := make([]string, 5)

1. 创建长度和容量声明切片

slice := make([]int, 3, 5) // 长度为3个元素, 容量为5个元素

1. 通过切片字面量来声明切片(与数组声明的不同是方括号中没有数字代表的长度//)

// 其长度和容量都是5个元素
slice := []string{"Red", "Blue", "Green", "Yellow", "Pink"}
// 其长度和容量都是3个元素
slice := []int{10, 20, 30}

1. 使用索引声明切片

slice := []string{99: ""} // 初始化了第100个元素

1. 创建nil切片

var slice []int

1. 创建空切片

slice := make([]int, 0)
slice := []int{}

1. 使用切片创建切片

slice := []int{1,2,3,4,5}
newSlice := slice[1:3] // 2, 3, 4

1. 使用append增加元素

slice := []int{1,2,3,4,5}
newSlice := slice[1:3] // 切片是左闭右开区间
newSlice = append(newSlice, 10) // [1,2,3,10,5] 修改会影响到原始数组

1. 使用三个索引创建切片

slice := source[2,3,4] // 长度为1个元素(3-2) 容量为2个元素{4-2}

1. 设置长度和容量一致的好处

source := []string{"Apple", "Orange", "Plum", "Banana", "Grape"}
slice := source[2:3:3]
slice = append(slice, "Kiwi")

1. 将一个切片追加到另一个切片

s1 := []int{1, 2}
s2 := []int{3, 4}
fmt.Printf("%v\n", append(s1, s2...)) // [1 2 3 4]

1. 迭代切片

slice := []int{1, 2, 3, 4}
for index, value := range slice {
	fmt.Printf("Index: %d Value: %d\n", index, value) // Index: 0 Value 1  etc...
}

slice := []int{1, 2, 3, 4}
for index := 2; index < len(slice); index++ {
	fmt.Printf("Index: %d Value: %d\n", index, slice[index])
}
// output:
// Index: 2 Value: 3
// Index: 3 Value: 4

1. 组合切片的切片

slice := [][]int{{10}, {100, 200}}
slice[0] = append(slice[0], 20) // [{10, 20}, {100, 200}]

映射

1. 使用make声明映射

dict := make(map[string]int)
// 直接创建
dict := map[string]string{"Red": "#xxx", "Orange": "#xxx"}

1. 映射赋值

colors := map[string]string{}
colors["Red"] = "#xxx"

1. 判断映射值是否存在

value, exists := colors["Blue"]
if exists {
	// XXX
}
// or use
value := colors["Blue"]
if value !== "" {
	// XXX
}

1. 使用range迭代映射

for key, value := range colors {
	fmt.Printf("Key: %s Value: %s\n", key, value)
}

1. 删除映射的某一项

delete(colors, "Coral") // 只能用在映射存储的值都是非零值的情况

1. 在函数间传递映射

类型系统

用户定义的类型

1. 定义一个结构类型

type user struct {
	name string
	email string
	ext int
	provileged bool
}

1. 使用结构类型声明变量, 并初始化为其零值

var bill user

1. 使用结构字面量来声明一个结构类型的变量

lisa := user{
	name: "Lisa",
	email: "lisa@email.com",
	ext: 123,
	privileged: true,
}

1. 不适用字段名来创建结构类型的值

lisa := user{"Lisa", "lisa@email.com", 123, true}

1. 使用其他结构类型声明字段

type admin struct {
	person user
	level string
}

1. 使用结构字面量来创建字段值

fred := admin {
	person: user {
		name: "Lisa",
		email: "lisa@email.com",
		ext: 123,
		privileged: true,
	},
	level: "super",
}

1. 基于原始类型创建一个新类型

type Duration int64

方法

type user struct {
	name string
	email string
}

1. 值接受者

func (u user) notify() {
	// ...
}

1. 指针接受者

func (u *user) changeEmail(email string) {
	u.email = email
}

类型的本质

接口

实现

方法集

多态

嵌入类型

// 如果一个文件中定义的类型struct是这样
type User struct {
	Name string
	email string
}
// 在另一个文件中调用
u := entities.User {
	Name: "Bill",
	email: "bill@email.com" // error
}

type User struct {
	Name: string
	Email: string
}
type Admin struct {
	user
	Rights int
}

// 使用
a := entities.Admin {
	Rights: 10
}
// 通过点语法为内嵌类型的公开类型赋值
a.Name = "Bill"
a.Email = "bill@email.com"

并发

并发与并行

线程与进程

goroutine

runtime.GOMAXPROCS(1)

var wg sync.WaitGroup
// 声明需要等待2个goroutine
wg.add(2)

go func(){
	defer wg.Done()
}()
go func(){
	defer wg.Done()
}()
wg.Wait()

锁住共享资源

var (
	counter int64
	wg sync.WaitGroup
)
func main() {
	wg.add(2)
	go incCounter(1)
	go incCounter(2)
	wg.Wait()

	fmt.Println("Final Counter:", counter)
}
func incCounter(id: int) {
	defer wg.Done()
	for count := 0; count < 2; count++ {
		atomic.AddInt64(&counter, 1)
		// 当前goroutine从线程退出, 并放回到队列
		runtime.Gosched()
	}
}

互斥锁

var (
	counter int
	wg sync.WaitGroup
	mutex sync.Mutex
)
func main() {
	wg.Add(2)
	go.incCounter(1)
	go.incCounter(2)

	wg.Wait()
	fmt.Printf("Final Counter: %d\n", counter)
}
func incCounter(id: int) {
	defer wg.Done()
	for count := 0; count < 2; count++ {
		// 同一时刻只允许一个goroutine进入这个临界区
		mutex.Lock()
		{
			// 捕获counter的值
			value := counter
			// 当前goroutine从线程退出, 放回队列
			runtime.Gosched()
			// 增加本地value变量的值
			value++
			// 将该值保存到counter
			counter = value
		}
		// 释放锁, 允许其他正在等待的goroutine进入临界区
		mutex.Unlock()
	}
}

通道

1. 使用make创建通道

unbuffered := make(chan int)
buffered := make(chan string, 10)

1. 向通道发送值

buffered := make(chan string, 10)
buffered <- "Gopher"

1. 从通道接收值

value := <-buffered

runner

pool

work