个人在青训营的学习总结

从实例来学习一门编程语言，把编程语言各个重要的知识点通过例子展现出来，更加生动形象,动手参与敲代码的实践当中才有最好的学习效果

记录我认为会比较容易忘记的知识点，适当补充，整理总结，以及自己的心得体会

学习地址

两个 Go 教程平台 github 项目地址

两个 Go 教程平台

主要内容

包、变量、函数、流程控制、数组、结构体、切片、映射、面向对象、接口，基础知识与进阶知识。

基础知识

包的使用

导入包并使用

每个 Go 程序都是由包构成的。

程序从 main 包开始运行。

按照约定，包名与导入路径的最后一个元素一致。例如，"math/rand" 包中的源码均以 package rand 语句开始。

package main

import (
    "fmt"
    "math/rand"
)

func main() {
    fmt.Println("My favorite number is", rand.Intn(10))
}

产生随机数每次都一样

此程序的运行环境是固定的，因此 rand.Intn 总是会返回相同的数字。（要得到不同的数字，需为生成器提供不同的种子数)

我们编写如下代码，第一次直接使用 rand 生成随机数，第二次通过时间戳生成一个种子提供给生成器获得 r 生成器对象，再通过 r 生成随机数。如果看不懂可略先跳过，具体会在随机数章节讲到。

package main

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

func main() {
    // ^ 因为运行环境固定,返回的随机数永远是固定值
    fmt.Println("第一次 我最喜欢的数字")
    fmt.Println("第一个数字", rand.Intn(10))
    fmt.Println("第二个数字", rand.Intn(10))
    fmt.Println("第三个数字", rand.Intn(10))

    // ^ 使用时间戳生成一个种子重置化 rand
    seed := rand.NewSource(time.Now().Unix())
    r := rand.New(seed)

    // ^ 再生成随机数
    fmt.Println("第二次 我最喜欢的数字")
    fmt.Println("第一个数字", r.Intn(10))
    fmt.Println("第二个数字", r.Intn(10))
    fmt.Println("第三个数字", r.Intn(10))
}

可以发现，无论运行多少次，第一次三个数字都是一样的，而第二次三个数字是变化的。

plaintext

第一次 我最喜欢的数字
第一个数字 1
第二个数字 7
第三个数字 7
第二次 我最喜欢的数字
第一个数字 7
第二个数字 0
第三个数字 7

因为运行环境是固定的，使用 rand 标准库，如果不给定新的种子，那么程序每次运行生成的随机数都是一样的。

导入多个包

// ^ 第一种方式
import "fmt"
import "math"

// ^ 第二种方式
import (
"fmt"
"math"
)

导出名（公开、Public）

在 Go 中，如果一个名字以大写字母开头，那么它就是已导出的。例如，Pizza 就是个已导出名，Pi 也同样，它导出自 math 包。

将首字母大写，类似 Java、C# 中的 Public 修饰符，称为公共函数、变量，其他包能够使用。小写称为私有函数、变量，类似 Java、C# 中的 private 修饰符，只能在内部使用。

plaintext

目录结构：
└───2_Public
    │   main.go
    │
    ├───hello
    │       hello.go
    │
    └───world
            world.go

hello.go

package hello

import "fmt"

var PI float64 = 3.1415926
var Count int = 1
var count int = 1

func Hello() {
    fmt.Println("Hello")
}

func hello() {
    fmt.Println("hello")
}

func world() {
    fmt.Println("World")
}

world.go

package world

func World() {
    println("World")
}

main.go

package main

import (
    "Work/Work/Study/Basics/2_Public/hello"
    w "Work/Work/Study/Basics/2_Public/world"
    "fmt"
)

func main() {
    fmt.Println("导出名的使用")
    fmt.Println(hello.PI)
    hello.Hello()
    // ^ 在 import 中对 world 包起别名 w
    w.World()
}

可以看到只有大写开头的函数或变量标识符能被其他包使用。

函数

函数写法

要注意 go 语言的函数参数类型要写在形参后面。

package main

import "fmt"

func add(x int, y int) int {
    return x + y
}

func main() {
    fmt.Println(add(42, 13))
}

形参类型相同

当连续两个或多个函数的已命名形参类型相同时，除最后一个类型以外，其它都可以省略。

func add(x, y int) int {
    return x + y
}

返回多个值

函数可以返回任意数量的返回值。

func swap(x, y string) (string, string) {
    return y, x
}

func main() {
    a, b := swap("hello", "world")
    fmt.Println(a, b)
}

没有参数的return

Go 的返回值可被命名，它们会被视作定义在函数顶部的变量。

没有参数的 return 语句返回已命名的返回值。也就是 直接 返回。

直接返回语句应当仅用在短的函数中。在长的函数中它们会影响代码的可读性。

func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return
}

func main() {
    fmt.Println(split(17))
}

变量

变量命名

var 语句用于声明一个变量列表，跟函数的参数列表一样，类型在最后。var 语句可以出现在包或函数级别。

package main

import "fmt"

var c, python, java bool

func main() {
    var i int
    fmt.Println(i, c, python, java)
}

从初始值获取类型

变量声明可以包含初始值，每个变量对应一个。

如果初始化值已存在，则可以省略类型；变量会从初始值中获得类型。

短变量声明

在函数中，简洁赋值语句 := 可在类型明确的地方代替 var 声明。

函数外的每个语句都必须以关键字开始（var, func 等等），因此 := 结构不能在函数外使用。

基本类型

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // uint8 的别名

rune // int32 的别名
    // 表示一个 Unicode 码点

float32 float64

complex64 complex128

int, uint 和 uintptr 在 32 位系统上通常为 32 位宽，在 64 位系统上则为 64 位宽。

当你需要一个整数值时应使用 int 类型，除非你有特殊的理由使用固定大小或无符号的整数类型。

你可以像import那样分组成一个语法块声明并初始化变量。

var (
    ToBe   bool       = false
    MaxInt uint64     = 1<<63
    z      complex128 = cmplx.Sqrt(-5 + 12i)
)

零值

如果你没有明确初始化变量则会自动赋予零值。

func main() {
    var i int
    var f float64
    var b bool
    var s string
    fmt.Printf("%v %v %v %q\n", i, f, b, s)
}

//0 0 false ""

类型转换

这点有点类似 python 的类型转换。表达式 T(v) 将值 v 转换为类型 T。

var i int = 42
var f float64 = float64(i)
var u uint = uint(f)

i := 42
f := float64(i)
u := uint(f)

Go 在不同类型的项之间赋值时需要显式转换。

类型推导

声明一个变量而不指定其类型时（即使用不带类型的 := 语法或 var = 表达式语法），变量的类型由右值推导得出。

当右值声明了类型时，新变量的类型与其相同。

var i int
j := i // j 也是一个 int

当右边包含未指明类型的数值常量时，新变量的类型就可能是 int, float64 或 complex128 了，这取决于常量的精度。

i := 42           // int
f := 3.142        // float64
g := 0.867 + 0.5i // complex128

例如，用类型转换或浮点数语法来声明并初始化一个浮点数值。

z := 1.0
z := float64(1)

常量

常量的声明与变量类似，只不过是使用 const 关键字。

常量可以是字符、字符串、布尔值或数值。

常量不能用 := 语法声明。

数值常量

数值常量是高精度的值。

一个未指定类型的常量由上下文来决定其类型。

int 可以存放最大64位的整数，根据平台不同有时会更少。

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

plaintext

21
0.2
1.2676506002282295e+29

可以看到没有使用 needInt(Big) 是因为 Int 最多只能存储 64 位的整数，而我们传入的形参已经到了 2^100 , 所以用精度更高的 float64 完成

流程控制

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 实现）

上面的代码，去掉分号， C 的 while 在 Go 中叫做 for。

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 十进制的整数格式。
参数列表： 多个参数以逗号分隔，个数必须与格式化样式中的个数一一对应，否则运行时会报错。

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

if 简短语句

同 for 一样， if 语句可以在条件表达式前执行一个简单的语句。

该语句声明的变量作用域仅在 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),
    )
}

如果将 pow 函数最后的 return lim 改为 return v 则会报错 undefined: v。切记作用域仅在 if else 内部

if 和 else

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

%g 格式符

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

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

练习：循环与函数

题目地址：tour.go-zh.org/flowcontrol…

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

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

plaintext

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

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

在提供的 func Sqrt 中实现它。无论输入是什么，对 z 的一个恰当的猜测为 1。要开始，请重复计算 10 次并随之打印每次的 z 值。观察对于不同的值 x（1、2、3 ...），你得到的答案是如何逼近结果的，猜测提升的速度有多快。

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

plaintext

1.5
1.4166666666666667
1.4142156862745099
1.4142135623746899
1.4142135623746899

Switch

Go 的 switch 语句类似于 C、C++、Java、JavaScript 中的，不过 Go 只运行选定的 case，而非之后所有的 case。实际上，Go 自动提供了在这些语言中每个 case 后面所需的 break 语句。除非以 fallthrough 语句结束，否则分支会自动终止。 Go 的另一点重要的不同在于 switch 的 case 无需为常量，且取值不必为整数。

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==0 时 f 不会被调用。

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

plaintext

hello
world

Defer 栈

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

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

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

    fmt.Println("done")
}

plaintext

counting
done
2
1
0

数据结构

指针

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

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

& 操作符会生成一个指向其操作数的指针。即获取变量的内存地址

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

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

plaintext

0xc000016088
42
0xc000016088
21

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

结构体

定义、访问结构体

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

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

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

plaintext

{1000000000 2}

如果我们有一个指向结构体的指针 p，那么可以通过 (*p).X 来访问其字段 X。不过这么写太啰嗦了，Go 允许我们使用隐式间接引用，直接写 p.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)
}

plaintext

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

数组

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

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

plaintext

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

切片 Slice

声明切片

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

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

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

plaintext

a[low : high]

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

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

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

plaintext

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

plaintext

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

plaintext

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

截取默认行为

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

对于数组

var a [10]int

来说，以下切片是等价的

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

切片的长度与容量

切片拥有长度和容量。

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

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

切片 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 且没有底层数组。

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 %v\n",
        s, len(x), cap(x), x)
}

plaintext

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("%s\n", strings.Join(board[i], " "))
    }
}

plaintext

X _ X
O _ X
_ _ O

strings.Join(board[i], " ") 使用间隔符“ ”合并切片数组元素返回一个字符串

向切片追加元素

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

append 的第一个参数 s 是一个元素类型为 T 的切片，其余类型为 T 的值将会追加到该切片的末尾。

append 的结果是一个包含原切片所有元素加上新添加元素的切片。

当 s 的底层数组太小，不足以容纳所有给定的值时，它就会分配一个更大的数组。返回的切片会指向这个新分配的数组。

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 %v\n", len(s), cap(s), s)
}

plaintext

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

for 循环的 range 形式可遍历切片或映射。

当使用 for 循环遍历切片时，每次迭代都会返回两个值。第一个值为当前元素的下标，第二个值为该下标所对应元素的一份副本。

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

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

plaintext

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("%d\n", value)
    }
}

plaintext

1
2
4

练习：切片

题目地址：tour.go-zh.org/moretypes/1…

实现 Pic。它应当返回一个长度为 dy 的切片，其中每个元素是一个长度为 dx，元素类型为 uint8 的切片。当你运行此程序时，它会将每个整数解释为灰度值（好吧，其实是蓝度值）并显示它所对应的图像。

图像的选择由你来定。几个有趣的函数包括 (x+y)/2, x*y, x^y, x*log(y) 和 x%(y+1)。

（提示：需要使用循环来分配 [][]uint8 中的每个 []uint8；请使用 uint8(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)
}

微服务的学习总结

微服务使用的优点：

1：微服务将业务分成多个服务，使得各个模块之间的开发者弄清自己的业务就可以，专注于自己的业务逻辑，实现业务和代码之间的松耦合。

2：各个模块之间的调用采用借口调用的方式，这也使得开发人员必须将业务进行封装，并且暴露给其他服务进行调用。相应了人们所提倡的接口编程。并且对开发人员的编程设计习惯起到好的作用。

3：各个服务之间相对独立，一个服务断掉，并不影响其他服务的运行。因此在采用多服务器部署时，服务整块服务断掉的概率较小。

4：微服务既然将整体业务进行拆分，因此服务具有可复用性，整个模块都可以拿来使用。 PS：由于各个微服务有自己独立的数据库，即传统的单架构方式的数据库根据业务拆分出来。微服务之间进行数据交互时，可能出现某些服务失败的情况，此时就出现了数据的不一致性。违背了关系型数据的ACID中的一致性。A：原子性 C：一致性 I：隔离性 D：永久性

Redis的学习总结

Redis的优缺点

优点

读写性能优异， Redis能读的速度是110000次/s，写的速度是81000次/s。支持数据持久化，支持AOF和RDB两种持久化方式。支持事务，Redis的所有操作都是原子性的，同时Redis还支持对几个操作合并后的原子性执行。数据结构丰富，除了支持string类型的value外还支持hash、set、zset、list等数据结构。支持主从复制，主机会自动将数据同步到从机，可以进行读写分离。

缺点

数据库容量受到物理内存的限制，不能用作海量数据的高性能读写，因此Redis适合的场景主要局限在较小数据量的高性能操作和运算上。 Redis 不具备自动容错和恢复功能，主机从机的宕机都会导致前端部分读写请求失败，需要等待机器重启或者手动切换前端的IP才能恢复。主机宕机，宕机前有部分数据未能及时同步到从机，切换IP后还会引入数据不一致的问题，降低了系统的可用性。 Redis 较难支持在线扩容，在集群容量达到上限时在线扩容会变得很复杂。为避免这一问题，运维人员在系统上线时必须确保有足够的空间，这对资源造成了很大的浪费。

数据类型

Redis主要有5种数据类型，包括String，List，Set，Zset，Hash，满足大部分的使用要求具体可以参考Redis数据类型

使用场景

由于Redis优异的读写性能，持久化支持等优势，Redis的使用场景非常多，主要包括计数器，缓存，消息队列，分布式锁等，具体使用场景可以参考Redis使用场景

持久化

Redis 是内存型数据库，为了之后重用数据（比如重启机器、机器故障之后回复数据），或者是为了防止系统故障而将数据备份到一个远程位置，需要将内存中的数据持久化到硬盘上。

Redis 提供了RDB和AOF两种持久化方式。默认是只开启RDB，当Redis重启时，它会优先使用AOF文件来还原数据集。

Redis持久化详解可以参考Redis持久化

过期键的删除策略

Redis中有个设置时间过期的功能，即对存储在 redis 数据库中的值可以设置一个过期时间。作为一个缓存数据库，这是非常实用的。如我们一般项目中的 token 或者一些登录信息，尤其是短信验证码都是有时间限制的，按照传统的数据库处理方式，一般都是自己判断过期，这样无疑会严重影响项目性能。

Redis有三种不同的删除策略：立即删除，惰性删除，定时删除

具体可以参考Redis过期键的删除策略

但是仅仅通过设置过期时间还是有问题的。我们想一下：如果定期删除漏掉了很多过期 key，然后你也没及时去查，也就没走惰性删除，此时会怎么样？如果大量过期key堆积在内存里，导致redis内存块耗尽了。怎么解决这个问题呢？ redis 数据淘汰策略。

数据淘汰策略

可以设置内存最大使用量，当内存使用量超出时，会施行数据淘汰策略。

数据淘汰策略详解可参考Redis数据淘汰策略

Redis与Memcached的区别

两者都是非关系型内存键值数据库，现在公司一般都是用 Redis 来实现缓存，而且 Redis 自身也越来越强大了！Redis 与 Memcached 的区别请参考Redis与Memcached的区别

事务

Redis 通过 MULTI、EXEC、WATCH 等命令来实现事务(transaction)功能。事务提供了一种将多个命令请求打包，然后一次性、按顺序地执行多个命令的机制，并且在事务执行期间，服务器不会中断事务而改去执行其他客户端的命令请求，它会将事务中的所有命令都执行完毕，然后才去处理其他客户端的命令请求。

事务中的多个命令被一次性发送给服务器，而不是一条一条发送，这种方式被称为流水线，可以减少客户端与服务器之间的网络通信次数从而提升性能。

在传统的关系式数据库中，常用 ACID 性质来检验事务功能的可靠性和安全性。在 Redis 中，事务总是具有原子性（Atomicity）、一致性（Consistency）和隔离性（Isolation），并且当 Redis 运行在某种特定的持久化模式下时，事务也具有持久性（Durability）。

RPC框架学习总结

RPC介绍

RPC（Remote Procedure Call）远程过程调用，简单的理解是一个节点请求另一个节点提供的服务
本地过程调用：如果需要将本地student对象的age+1，可以实现一个addAge()方法，将student对象传入，对年龄进行更新之后返回即可，本地方法调用的函数体通过函数指针来指定。
远程过程调用：上述操作的过程中，如果addAge()这个方法在服务端，执行函数的函数体在远程机器上，如何告诉机器需要调用这个方法呢？

首先客户端需要告诉服务器，需要调用的函数，这里函数和进程ID存在一个映射，客户端远程调用时，需要查一下函数，找到对应的ID，然后执行函数的代码。
客户端需要把本地参数传给远程函数，本地调用的过程中，直接压栈即可，但是在远程调用过程中不再同一个内存里，无法直接传递函数的参数，因此需要客户端把参数转换成字节流，传给服务端，然后服务端将字节流转换成自身能读取的格式，是一个序列化和反序列化的过程。 3.数据准备好了之后，如何进行传输？网络传输层需要把调用的ID和序列化后的参数传给服务端，然后把计算好的结果序列化传给客户端，因此TCP层即可完成上述过程，gRPC中采用的是HTTP2协议。

RPC 是一种技术思想而非一种规范或协议，常见 RPC 技术和框架有：

应用级的服务框架： 阿里的 Dubbo/Dubbox、Google gRPC、Spring Boot/Spring Cloud。
远程通信协议： RMI、Socket、SOAP(HTTP XML)、REST(HTTP JSON)。
通信框架： MINA 和 Netty。

完整的 RPC 框架

在一个典型 RPC 的使用场景中，包含了服务发现、负载、容错、网络传输、序列化等组件，其中“RPC 协议”就指明了程序如何进行网络传输和序列化。

RPC 框架的重要组成：

客户端（Client）： 服务调用方。
客户端存根（Client Stub）： 存放服务端地址信息，将客户端的请求参数数据信息打包成网络消息，再通过网络传输发送给服务端。
服务端存根（Server Stub）： 接收客户端发送过来的请求消息并进行解包，然后再调用本地服务进行处理。
服务端（Server）： 服务的真正提供者。
Network Service： 底层传输，可以是 TCP 或 HTTP。

最后想说的话

1、首先应该尊重编程，热爱你所写下的程序，他是你的伙伴，而不是工具。

2、可以让步，却不可以退缩，可以羞涩，却不可以软弱，总之，必须勇敢。

3、编程是一种单调的生活，因此比普通人需要更多的关怀，更多的友情。

4、程序不是年轻的专利，但是，他属于年轻。 5、没有情调，不懂浪漫，也许这是程序员的一面，但拥有朴实无华的爱是他们的另一面。

个人青训营学习总结｜ 青训营

个人在青训营的学习总结

学习地址

主要内容

基础知识

包的使用

导入包并使用

产生随机数每次都一样

导入多个包

导出名（公开、Public）

函数

函数写法

形参类型相同

返回多个值

没有参数的return

变量

变量命名

从初始值获取类型

短变量声明

基本类型

零值

类型转换

类型推导

常量

数值常量

流程控制

for 循环

while 循环（for 实现）

死循环

if 判断

fmt.Sprint 格式化字符串

if 简短语句

if 和 else

%g 格式符

练习：循环与函数

Switch

求值顺序

没有条件

Defer

Defer 栈

数据结构

指针

结构体

定义、访问结构体

结构体文法

数组

切片 Slice

声明切片

切片如同数组的引用

切片文法

截取默认行为

切片的长度与容量

nil 切片零值

make 创建切片

切片的切片

向切片追加元素

Range

使用 _ 忽略值

练习：切片

微服务的学习总结

微服务使用的优点：

Redis的学习总结

Redis的优缺点

优点

缺点

数据类型

使用场景

持久化

过期键的删除策略

数据淘汰策略

Redis与Memcached的区别

事务

RPC框架学习总结

RPC介绍

完整的 RPC 框架

RPC 框架的重要组成：

最后想说的话

个人青训营学习总结｜青训营