准备工作&x1f600; - Golang教程网

const (
	// 将 1 左移 100 位来创建一个非常大的数字
	// 即这个数的二进制是 1 后面跟着 100 个 0
	Big = 1 << 100
	// 再往右移 99 位，即 Small = 1 << 1，或者说 Small = 2
	Small = Big >> 99
)

func needInt(x int) int { return x*10 + 1 }
func neeDFloat(x float64) float64 {
	return x * 0.1
}

func main() {
	fmt.Println(needInt(Small))
	fmt.Println(needFloat(Small))
	fmt.Println(needFloat(Big))
}

21
0.2
1.2676506002282295e+29

needInt(Big)Int2^100float64

流程控制

for 循环

Go 唯一的循环结构，由三部分组成，跟其他语言一样。不用写圆括号，必须要写花括号！

false

func main() {
	sum := 0
	for i := 0; i < 10; i++ {
		sum += i
	}
	fmt.Println(sum)
}

初始化语句、后置语句可选

func main() {
	sum := 1
	for ; sum < 1000; {
		sum += sum
	}
	fmt.Println(sum)
}

while 循环（for 实现）

whilefor

func main() {
	sum := 1
	for sum < 1000{
		sum += sum
	}
	fmt.Println(sum)
}

死循环

func main() {
	for {
	}
}

if 判断

package main

import (
	"fmt"
	"math"
)

func sqrt(x float64) string {
	if x < 0 {
		return sqrt(-x) + "i"
	}
	return fmt.Sprint(math.Sqrt(x))
}

func main() {
	fmt.Println(sqrt(2), sqrt(-4))
}

fmt.Sprint 格式化字符串

fmt.Sprintf(格式化样式, 参数列表…)

格式化样式：字符串形式，格式化符号以 % 开头， %s 字符串格式，%d 十进制的整数格式。
参数列表：多个参数以逗号分隔，个数必须与格式化样式中的个数一一对应，否则运行时会报错。

完整列表参考：https://www.jianshu.com/p/66aaf908045e

格式	描述
%v	按值的本来值输出
%+v	在 %v 基础上，对结构体字段名和值进行展开
%#v	输出 Go 语言语法格式的值
%T	输出 Go 语言语法格式的类型和值
%%	输出 % 本体
%b	整型以二进制方式显示
%o	整型以八进制方式显示
%d	整型以十进制方式显示
%x	整型以十六进制方式显示
%X	整型以十六进制、字母大写方式显示
%U	Unicode 字符
%f	浮点数
%p	指针，十六进制方式显示
%c	输出单个字符
%s	输出字符串
%q	双引号围绕的字符串，由Go语法安全地转义
%g	小数不为0则显示小数，小数点右侧的0不显示

package main

import (
	"fmt"
)

tyPE point struct {
	x, y int
}

func main() {
	// go 中格式化字符串并赋值给新串，使用 fmt.Sprintf
	// %s 表示字符串
	var stockcode = "000987"
	var enddate = "2020-12-31"
	var url = "Code=%s&endDate=%s"
	var target_url = fmt.Sprintf(url, stockcode, enddate)
	fmt.Println(target_url)

	// 另外一个实例，%d 表示整型
	const name, age = "Kim", 22 // 常量不能用 := 语法声明
	s := fmt.Sprintf("%s is %d years old.n", name, age)
	fmt.Println(s)

	p := point{1, 2}
	fmt.Printf("%vn", p)
	fmt.Printf("%+vn", p)
	fmt.Printf("%#vn", p)
	fmt.Printf("%Tn", p)
	fmt.Printf("%tn", true)
	fmt.Printf("%dn", 123)
	fmt.Printf("%bn", 14)
	fmt.Printf("%cn", 33)
	fmt.Printf("%xn", 456)
	fmt.Printf("%fn", 78.9)
	fmt.Printf("%gn", 78.9) // ^ 这个很好用
	fmt.Printf("%en", 123400000.0)
	fmt.Printf("%En", 123400000.0)
	fmt.Printf("%sn", ""string"")
	fmt.Printf("%qn", ""string"")
	fmt.Printf("%xn", "hex this")
	fmt.Printf("%pn", &p)
	fmt.Printf("|%6d|%6d|n", 12, 345) // ^ 默认右对齐
	fmt.Printf("|%6.2f|%6.2f|n", 1.2, 3.45)
	fmt.Printf("|%-6.2f|%-6.2f|n", 1.2, 3.45)
	fmt.Printf("|%6s|%6s|n", "foo", "b")
	fmt.Printf("|%-6s|%-6s|n", "foo", "b")
	ss := fmt.Sprintf("a %s", "string")
	fmt.Println(ss)
}

Code=000987&endDate=2020-12-31
Kim is 22 years old.

{1 2}
{x:1 y:2}
main.point{x:1, y:2}
main.point
true
123
1110
!
1c8
78.900000
78.9
1.234000e+08
1.234000E+08
"string"
""string""
6865782074686973
0xc0000160c0
|    12|   345|
|  1.20|  3.45|
|1.20  |3.45  |
|   foo|     b|
|foo   |b     |
a string

if 简短语句

forif

if

func pow(x, n, lim float64) float64 {
	if v := math.Pow(x, n); v < lim {
		return v
	}
	return lim
}

func main() {
	fmt.Println(
		pow(3, 2, 10),
		pow(3, 3, 20),
	)
}

powreturn limreturn vundefined: v

if 和 else

func pow(x, n, lim float64) float64 {
	if v := math.Pow(x, n); v < lim {
		return v
	} else {
		fmt.Printf("%g >= %gn", v, lim)
	}
	// 这里开始就不能使用 v 了
	return lim
}

%g 格式符

12.3+12.7如果使用%f输出，你将会得到25.000000，而有的时候你并不想要小数点末尾这么多的0，你可能会选择强制转换成int类型，但是这样子会显得有点繁琐，这个时候%g的妙用就体现出来了，使用%g格式符输出之后，直接得到25了，它会自动将小数点后面没用的0过滤掉。

'g’使用小写字母，'G’使用大写字母。小数点右侧的尾数0不被显示；显示小数点仅当输出的小数部分不为0。

练习：循环与函数

题目地址：https://tour.go-zh.org/flowcontrol/8

为了练习函数与循环，我们来实现一个平方根函数：用牛顿法实现平方根函数。

计算机通常使用循环来计算 x 的平方根。从某个猜测的值 z 开始，我们可以根据 z² 与 x 的近似度来调整 z，产生一个更好的猜测

z -= (z*z - x) / (2*z)

重复调整的过程，猜测的结果会越来越精确，得到的答案也会尽可能接近实际的平方根。

func Sqrt

func Sqrt(x float64) float64 {
	z := 1.0 // ^ 给定类型浮点数值
	for math.Abs(z*z-x) > 0.000001 {
		z -= (z*z - x) / (2 * z)
		fmt.Println(z)
	}
	return z
}

func main() {
	fmt.Println(Sqrt(2))
}

1.5
1.4166666666666667
1.4142156862745099
1.4142135623746899
1.4142135623746899

Switch

breakfallthrough

func main() {
	fmt.Print("Go runs on ")
	switch os := runtime.GOOS; os {
	case "darwin":
		fmt.Println("OS X.")
	case "linux":
		fmt.Println("Linux.")
	default:
		// plan9, windows...
		fmt.Printf("%s.n", os)
	}
}

switch 条件前可以写赋值表达式，作用域在 switch 内部

求值顺序

switch 的 case 语句从上到下顺次执行，直到匹配成功时停止。

i==0f

switch i {
case 0:
case f():
}

判断距离星期六还有多久

func main() {
	fmt.Println("When's Saturday?")
	today := time.Now().Weekday()
	switch time.Saturday {
	case today + 0:
		fmt.Println("Today.")
	case today + 1:
		fmt.Println("Tomorrow.")
	case today + 2:
		fmt.Println("In two days.")
	default:
		fmt.Println("Too far away.")
	}
}

没有条件

switch true { …… }

func main() {
	t := time.Now()
	switch {
	case t.Hour() < 12:
		fmt.Println("Good morning!")
	case t.Hour() < 17:
		fmt.Println("Good afternoon.")
	default:
		fmt.Println("Good evening.")
	}
}

优点是能将一长串 if-then-else 写得更加清晰

Defer

defer 语句会将函数推迟到外层函数返回之后执行。

推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。

func main() {
	defer fmt.Println("world")

	fmt.Println("hello")
}

hello
world

Defer 栈

推迟的函数调用会被压入一个栈中。当外层函数返回时，被推迟的函数会按照后进先出的顺序调用。

func main() {
	fmt.Println("counting")

	for i := 0; i < 10; i++ {
		defer fmt.Println(i)
	}

	fmt.Println("done")
}

counting
done
2
1
0

数据结构

指针

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

*TTnil

func main() {
	i := 42
	p := &i
	fmt.Println(p)
	fmt.Println(*p)
	*p = 21
	fmt.Println(p)
	fmt.Println(*p)
}

0xc000016088
42
0xc000016088
21

注意 Go 没有指针运算，像 p = p + 1 会导致错误

结构体

定义、访问结构体

struct

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

type Vertex struct {
	X int
	Y int
}

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

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

type Vertex struct {
	X int
	Y int
}

func main() {
	v := Vertex{1, 2}
	p := &v
	p.X = 1e9 // 科学计数法
	fmt.Println(v)
}

{1000000000 2}

p(*p).XXp.X

结构体文法

Name:

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)
}

{1 2} &{1 2} {1 0} {0 0}

数组

[n]TnT

var a [10]int

数组的长度是其类型的一部分，因此数组不能改变大小。

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)
}

Hello World
[Hello World]
[2 3 5 7 11 13]

切片 Slice

声明切片

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

[]TT

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

a[low : high]

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

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

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

[3 5 7]

切片如同数组的引用

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

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)
}

[John Paul George Ringo]
[John Paul] [Paul George]
[John XXX] [XXX George]
[John XXX George Ringo]

更改切片的元素会修改其底层数组中对应的元素，与它共享底层数组的切片都会观测到这些修改。

切片文法

[3]bool{true, true, false} // 数组文法
[]bool{true, true, false} // 切片文法，创建一个和上面相同的数组，然后构建一个引用了它的切片

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)
}

[2 3 5 7 11 13]
[true false true true false true]
[{2 true} {3 false} {5 true} {7 true} {11 false} {13 true}]

我们可以在切片声明的时候定义结构体

s := []struct {
		i int
		b bool
	}{
		{2, true},
		{3, false}
     }

截取默认行为

对于数组

var a [10]int

来说，以下切片是等价的

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

切片的长度与容量

切片拥有长度和容量。

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

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

slen(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 %vn", 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 且没有底层数组。

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

[] 0 0
nil!

make 创建切片

make

make

a := make([]int, 5)  // len(a)=5
b := make([]int, 0, 5) // len(b)=0, cap(b)=5
// 注意看 len 的变化
b = b[:cap(b)] // len(b)=5, cap(b)=5
b = b[1:]      // len(b)=4, cap(b)=4

func main() {
	a := make([]int, 5)
	printSlice("a", a)

	b := make([]int, 0, 5)
	printSlice("b", b)

	c := b[:2]
	printSlice("c", c)

	d := c[2:5]
	printSlice("d", d)
}

func printSlice(s string, x []int) {
	fmt.Printf("%s len=%d cap=%d %vn",
		s, len(x), cap(x), x)
}

a len=5 cap=5 [0 0 0 0 0]
b len=0 cap=5 []
c len=2 cap=5 [0 0]
d len=3 cap=3 [0 0 0]

切片的切片

切片可包含任何类型，甚至包括其它的切片。

func main() {
	// 创建一个井字板（经典游戏）
	board := [][]string{
		[]string{"_", "_", "_"},
		[]string{"_", "_", "_"},
		[]string{"_", "_", "_"},
	}

	// 两个玩家轮流打上 X 和 O
	board[0][0] = "X"
	board[2][2] = "O"
	board[1][2] = "X"
	board[1][0] = "O"
	board[0][2] = "X"

	for i := 0; i < len(board); i++ {
		fmt.Printf("%sn", strings.Join(board[i], " "))
	}
}

X _ X
O _ X
_ _ O

strings.Join(board[i], " ")

向切片追加元素

func append(s []T, vs ...T) []T

appendsTT

append

func main() {
	var s []int
	printSlice(s)

	// 添加一个空切片
	s = append(s, 0)
	printSlice(s)

	// 这个切片会按需增长
	s = append(s, 1)
	printSlice(s)

	// 可以一次性添加多个元素
	s = append(s, 2, 3, 4)
	printSlice(s)
}

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

len=0 cap=0 []
len=1 cap=1 [0]
len=2 cap=2 [0 1]
len=5 cap=6 [0 1 2 3 4]

Range

forrange

for

var pow = []int{1, 2, 4, 8, 16}

func main() {
	for i, v := range pow {
		fmt.Printf("2**%d = %dn", i, v)
	}
}

2**0 = 1
2**1 = 2
2**2 = 4
2**3 = 8
2**4 = 16

使用 _ 忽略值

for i, _ := range pow
for _, value := range pow
for i := range pow

遍历切片，使用下标、位运算符进行切片元素赋值

func main() {
	pow := make([]int, 3)
	for i := range pow {
		pow[i] = 1 << uint(i) // == 2**i
	}
	for _, value := range pow {
		fmt.Printf("%dn", value)
	}
}

1
2
4

练习：切片

题目地址：https://tour.go-zh.org/moretypes/18

Picdydxuint8

(x+y)/2x*yx^yx*LOG(y)x%(y+1)

[][]uint8[]uint8uint8(intValue)math

第一种写法

package main

import "golang.org/x/tour/pic"

func Pic(dx, dy int) [][]uint8 {
	res := make([][]uint8, dy)
	for i := 0; i < dy; i++ {
		temp := make([]uint8, dx)
		for i := 0; i < dx; i++ {
			temp[i] = uint8(i)
		}
		res[i] = temp // ^ res = append(res, temp) 这个是添加
	}
	return res
}

func main() {
	pic.Show(Pic)
}

第二种写法

package main

import "golang.org/x/tour/pic"

func Pic(dx, dy int) [][]uint8 {
	res := make([][]uint8, 0, dy)
	for j := 0; j < dy; j++ {
		res = append(res, make([]uint8, dx))
		for k := 0; k < dx; k++ {
			res[j][k] = uint8(j+k)/2
		}
	}
	return res
}

func main() {
	pic.Show(Pic)
}

映射 Map

映射声明与使用

映射将键映射到值。

nilnil

make

映射的文法与结构体相似，不过必须有键名。

package main

import "fmt"

type Vertex struct {
	Lat, Long float64
}

var m map[string]Vertex

var n = map[string]Vertex{
	"Bell Labs": Vertex{
		40.68433, -74.39967,
	},
	"GOOGLE": Vertex{
		37.42202, -122.08408,
	},
}

func main() {
	m = make(map[string]Vertex)
	m["Bell Labs"] = Vertex{
		40.68433, -74.39967,
	}
	fmt.Println(m["Bell Labs"])
   fmt.Println(n["Google"])
}

{40.68433 -74.39967}
{37.42202 -122.08408}

若顶级类型只是一个类型名，你可以在文法的元素中省略它。

var m = map[string]Vertex{
	"Bell Labs": {40.68433, -74.39967},
	"Google":    {37.42202, -122.08408},
}

修改映射

m[key] = elem

elem = m[key]

delete(m, key)

通过双赋值检测某个键是否存在（因为不存在默认也返回零值，要根据第二个参数判断）

elem, ok = m[key]

keymoktrueokfalse

keyelem

同样的，当从映射中读取某个不存在的键时，结果是映射的元素类型的零值。

elemok

elem, ok := m[key]

func main() {
	m := make(map[string]int)

	m["Answer"] = 42
	fmt.Println("The value:", m["Answer"])

	m["Answer"] = 48
	fmt.Println("The value:", m["Answer"])

	delete(m, "Answer")
	fmt.Println("The value:", m["Answer"])

	v, ok := m["Answer"]
	fmt.Println("The value:", v, "Present?", ok)
}

The value: 42
The value: 48
The value: 0
The value: 0 Present? false

练习：映射

题目地址：https://tour.go-zh.org/moretypes/23

WordCounts

你会发现 strings.Fields 很有帮助。

"……".split(' ')

package main

import (
	"strings"

	"golang.org/x/tour/wc"
)

func WordCount(s string) map[string]int {
	res := make(map[string]int)
	words := strings.Fields(s)
	for i := 0; i < len(words); i++ {
		word := words[i]
		res[word] += 1
	}
	return res
}

func main() {
	wc.Test(WordCount)
}

PASS
 f("I am learning Go!") = 
  map[string]int{"Go!":1, "I":1, "am":1, "learning":1}
PASS
 f("The quick brown fox jumped over the lazy dog.") = 
  map[string]int{"The":1, "brown":1, "dog.":1, "fox":1, "jumped":1, "lazy":1, "over":1, "quick":1, "the":1}
PASS
 f("I ate a donut. Then I ate another donut.") = 
  map[string]int{"I":2, "Then":1, "a":1, "another":1, "ate":2, "donut.":2}
PASS
 f("A man a plan a canal panama.") = 
  map[string]int{"A":1, "a":2, "canal":1, "man":1, "panama.":1, "plan":1}

函数值

作为参数或返回值

函数也是值。它们可以像其它值一样传递。

函数值可以用作函数的参数或返回值。

func compute(fn func(float64, float64) float64) float64 {
	return fn(3, 4)
}

func main() {
	hypot := func(x, y float64) float64 {
		return math.Sqrt(x*x + y*y)
	}
	fmt.Println(hypot(5, 12))

	fmt.Println(compute(hypot))
	fmt.Println(compute(math.Pow))
}

13
5
81

计时器包装

写一个包装函数添加运行计时功能的函数

func main() {
	myFunc := AddTimer(MyFor)
	myFunc()
}

func MyFor() bool {
	sum := 0
	for i := 0; i < 1000000000; i++ {
		sum += i
	}
	return true
}

func AddTimer(fn func() bool) func() bool {
	return func() bool {
		start := time.Now()
		result := fn()
		totalTime := time.Since(start)
		fmt.Println("共耗时", totalTime)
		return result
	}
}

共耗时 1.4966547s 秒

time.Now().Sub(t)

闭包

Go 函数可以是一个闭包。闭包是一个函数值，它引用了其函数体之外的变量。该函数可以访问并赋予其引用的变量的值，换句话说，该函数被这些变量“绑定”在一起。

addersum

func adder() func(int) int {
	sum := 0
	return func(x int) int {
		sum += x
		return sum
	}
}

func main() {
	pos, neg := adder(), adder()
	for i := 0; i < 4; i++ {
		fmt.Println(
			pos(i),
			neg(-2*i),
		)
	}
}