2019-05-21 Go语言学习二（接上）

三、更多类型：struct、slice和映射

1.指针

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) // 通过指针读取 i 的值
    *p = 21         // 通过指针设置 i 的值
    fmt.Println(i)  // 查看 i 的值

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

-------------------------------------------------------------------------------
//输出结果
42
21
73

2.结构体和结构体指针

（1）结构体

一个结构体（struct）就是一组字段（field）。
结构体字段使用点号来访问。

package main

import "fmt"

type Vertex struct {
    X int
    Y int
}

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

//运行结果：4

（2) 结构体指针

结构体字段可以通过结构体指针来访问。如果我们有一个指向结构体的指针 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
    fmt.Println(v)
}

//运行结果：{1000000000 2}

（3）结构体文法

结构体文法通过直接列出字段的值来新分配一个结构体。
使用 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)
}

//运行结果：{1 2} &{1 2} {1 0} {0 0}

3.数组

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

----------------------------------------------------------------------------
//运行结果：
Hello World
[Hello World]
[2 3 5 7 11 13]

4.切片

（1）切片介绍

每个数组的大小都是固定的。而切片则为数组元素提供动态大小的、灵活的视角。在实践中，切片比数组更常用。类型 []T 表示一个元素类型为 T 的切片。
切片通过两个下标来界定，即一个上界和一个下界，二者以冒号分隔： a[low : high] 它会选择一个半开区间，包括第一个元素，但排除最后一个元素
eg: 以下表达式创建了一个切片，它包含 a 中下标从 1 到 3 的元素： a[1:4]
切片并不存储任何数据，它只是描述了底层数组中的一段。
更改切片的元素会修改其底层数组中对应的元素。
与它共享底层数组的切片都会观测到这些修改。

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

----------------------------------------------------------------------------
//运行结果：
[John Paul George Ringo]
[John Paul] [Paul George]
[John XXX] [XXX George]
[John XXX George Ringo]

（2）切片文法

切片文法类似于没有长度的数组文法。
这是一个数组文法： [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}]

btw 切片的默认行为

在进行切片时，你可以利用它的默认行为来忽略上下界。
切片下界的默认值为 0，上界则是该切片的长度。
对于数组
var a [10]int
来说，以下切片是等价的：
a[0:10]
a[:10]
a[0:]
a[:]

（3）切片的长度和容量

切片拥有长度和容量。
切片的长度就是它所包含的元素个数。
切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。
切片 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)
    
    //将它扩展到超出容量范围 len = 6 cap = 6  错误输出
    //s := []int{2, 3, 5, 7, 11, 13}
    //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]

（4）nil切片

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

    var s []int
    fmt.Println(s, len(s), cap(s))
//输出:  [] 0 0

（5）用make创建切片

切片可以用内建函数 make 来创建，这也是你创建动态数组的方式。
make 函数会分配一个元素为零值的数组并返回一个引用了它的切片：
a := make([]int, 5) // len(a)=5
要指定它的容量，需向 make 传入第三个参数：
b := make([]int, 0, 5) // len(b)=0, cap(b)=5

b = b[:cap(b)] // len(b)=5, cap(b)=5
b = b[1:] // len(b)=4, cap(b)=4

    a := make([]int, 5)   // a len=5 cap=5 [0 0 0 0 0]
    b := make([]int, 0, 5) // b len=0 cap=5 []
    c := b[:2] // c len=2 cap=5 [0 0]
    d := c[2:5] // d len=3 cap=3 [0 0 0]

（6）切片的切片

切片可包含任何类型，甚至包括其它的切片。
eg：二维数组

package main
import (
    "fmt"
    "strings"
)
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], " "))
    }
}

-------------------------------------------------------------------------------
//运行结果：
X _ X
O _ X
_ _ O

（7）切片追加元素

为切片追加新的元素是种常用的操作，为此 Go 提供了内建的 append 函数。内建函数的文档对此函数有详细的介绍。
append 的第一个参数 s 是一个元素类型为 T 的切片，其余类型为 T 的值将会追加到该切片的末尾。
append 的结果是一个包含原切片所有元素加上新添加元素的切片。
当 s 的底层数组太小，不足以容纳所有给定的值时，它就会分配一个更大的数组。返回的切片会指向这个新分配的数组。

more: Go 切片：用法和本质

package main
import "fmt"
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)
}

------------------------------------------------------------------------------------
//运行结果：
len=0 cap=0 []
len=1 cap=1 [0]
len=2 cap=2 [0 1]
len=5 cap=6 [0 1 2 3 4]

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

//结果
2**0 = 1
2**1 = 2
2**2 = 4
2**3 = 8
2**4 = 16

range续

可以将下标或值赋予 _ 来忽略它。
for i, _ := range pow
for _, value := range pow
若你只需要索引，忽略第二个变量即可。
for i := range pow

package main
import "fmt"
func main() {
    pow := make([]int, 5)
    for i := range pow {
        pow[i] = 1 << uint(i) // == 2**i
    }
    for _, value := range pow {
        fmt.Printf("%d\n", value)
    }
}

---------------------------------------------------------------------------------
//运行结果：
1
2
4
8
16

* btw, 
uint(i)代表将i强转成uint类型，也就是无符号整型。
1<<uint(0) //1左移0位是1
1<<uint(1)//1左移1位是1*2=2
1<<uint(2)//1左移2位是1*2*2=4

6.映射 ('map')

（1）基本用法

map映射将键映射到值。
映射的零值为 nil 。nil 映射既没有键，也不能添加键。
make 函数会返回给定类型的映射，并将其初始化备用。

package main
import "fmt"
type Vertex struct {
    Lat, Long float64
}
var m map[string]Vertex
func main() {
    m = make(map[string]Vertex)
    m["Bell Labs"] = Vertex{
        40.68433, -74.39967,
    }
    fmt.Println(m["Bell Labs"])
} 

--------------------------------------------------------------------------------
//运行结果:
{40.68433 -74.39967}

（2）映射的文法

映射的文法与结构体相似，不过必须有键名。
若顶级类型只是一个类型名，你可以在文法的元素中省略它

package main
import "fmt"
type Vertex struct {
    Lat, Long float64
}
var m = map[string]Vertex{
    "Bell Labs": Vertex{
        40.68433, -74.39967,
    }, // 也可写成 "Bell Labs": {40.68433, -74.39967},
    "Google": Vertex{ 37.42202, -122.08408 }, // "Google":    {37.42202, -122.08408},
}

func main() {
    fmt.Println(m)
}

--------------------------------------------------------------------------------------
//运行结果:
map[Bell Labs:{40.68433 -74.39967} Google:{37.42202 -122.08408}]

（3）修改映射

在映射 m 中插入或修改元素：
m[key] = elem
获取元素：
elem = m[key]
删除元素：
delete(m, key)
通过双赋值检测某个键是否存在：
elem, ok = m[key]
若 key 在 m 中，ok 为 true ；否则，ok 为 false。
若 key 不在映射中，那么 elem 是该映射元素类型的零值。
同样的，当从映射中读取某个不存在的键时，结果是映射的元素类型的零值。
注：若 elem 或 ok 还未声明，你可以使用短变量声明：
elem, ok := m[key]

package main
import "fmt"
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"] 
//通过双赋值检测某个键是否存在 v,ok 仅仅只是一个表示符 也可换成其他的字母 不过记得把Println里面的v,ok换成对应的字母就可以了。
    fmt.Println("The value:", v, "Present?", ok)
}

// 运行结果;
The value: 42
The value: 48
The value: 0
The value: 0 Present? false

7.函数值和函数闭包

（1）函数值

函数也是值。它们可以像其它值一样传递。
函数值可以用作函数的参数或返回值。

package main 
import (    "fmt"   "math") 
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))   //调用hypot函数,输出13    
fmt.Println(compute(hypot))  //将hypot函数作为compute函数的参数，使用3，4作为调用hypot函数的参数调用，结果为5    
fmt.Println(compute(math.Pow))  //将math.Pow函数作为compute函数的参数，使用3，4作为调用math.Pow函数的参数调用，结果为81
}

（2）函数闭包

*用递归实现斐波那契数列

package main
import "fmt"
func fibonacci(n int) int {
  if n < 2 {
   return n
  }
  return fibonacci(n-2) + fibonacci(n-1)
}
func main() {
    var i int
    for i = 0; i < 10; i++ {
       fmt.Printf("%d\t", fibonacci(i))
    }
}

// 运行结果： 0    1    1    2    3    5    8    13    21    34

函数闭包实现斐波那契额数列

package main

import "fmt"

const LIM = 10

func main() {
    f := fibonacci() //返回一个闭包函数
    var array [LIM]int
    for i := 0; i < LIM; i++ {
        array[i] = f()
    }
    fmt.Println(array)
}

func fibonacci() func() int {
    back1, back2 := 0, 1
    return func() int {
        // 重新赋值
        back1, back2 = back2, (back1 + back2)
        return back1
    }
}

//运行结果：[1 1 2 3 5 8 13 21 34 55]

（2）闭包

闭包是匿名函数与匿名函数所引用环境的组合。匿名函数有动态创建的特性，该特性使得匿名函数不用通过参数传递的方式，就可以直接引用外部的变量。这就类似于常规函数直接使用全局变量一样，个人理解为：匿名函数和它引用的变量以及环境，类似常规函数引用全局变量处于一个包的环境。
CSDN闭包博文

func main() {
    n := 0
    f := func() int {
        n += 1
        return n
    }
    fmt.Println(f())  // 别忘记括号，不加括号相当于地址
    fmt.Println(f())
}
/*
输出：
1
2
*/

在上述代码中，

n := 0
f := func() int {
    n += 1
    return n
}

就是一个闭包，类比于常规函数+全局变量+包。f不仅仅是存储了一个函数的返回值，它同时存储了一个闭包的状态。

（3）闭包作为函数返回值

匿名函数作为返回值，不如理解理解为闭包作为函数的返回值，如下代码：

func Increase() func() int {
    n := 0
    return func() int {
        n++
        return n
    }
}

func main() {
    in := Increase()
    fmt.Println(in())
    fmt.Println(in())
}
/*
输出：
1
2
*/

闭包被返回赋予一个同类型的变量时，同时赋值的是整个闭包的状态，该状态会一直存在外部被赋值的变量in中，直到in被销毁，整个闭包也被销毁。

最后编辑于：2019.05.22 10:39:37

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 196,200评论 5赞 462
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 82,526评论 2赞 373
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 143,321评论 0赞 325
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 52,601评论 1赞 267
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 61,446评论 5赞 358
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 46,345评论 1赞 273
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 36,753评论 3赞 387
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 35,405评论 0赞 255
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 39,712评论 1赞 294
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 34,743评论 2赞 314
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 36,529评论 1赞 326
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 32,369评论 3赞 315
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 37,770评论 3赞 300
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,026评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 30,301评论 1赞 251
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 41,732评论 2赞 342
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 40,927评论 2赞 336