GoLang之旅（三）

时间：2020-01-08 02:02:52 阅读：67 评论：0 收藏：0 [点我收藏+]

指针

Go 拥有指针
指针保存了值的内存地址
类型 *T 是指向 T 类型值的指针，其零值为 nil

var p *int

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

i := 42
p = &i

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

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

这也就是通常所说的“间接引用”或“重定向”
与 C 不同，Go 没有指针运算

结构体

一个结构体（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
	fmt.Println(v)
}

结构体文法

结构体文法通过直接列出字段的值来新分配一个结构体
使用 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 个整数的数组
数组的长度是其类型的一部分，因此数组不能改变大小

切片

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

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

a[low : high]

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

以下表达式创建了一个切片，它包含 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)
}

切片文法

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

这是一个数组文法：

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

用 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

切片的切片

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

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

向切片追加元素

为切片追加新的元素是种常用的操作，为此 Go 提供了内建的 append 函数

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

append 的第一个参数 s 是一个元素类型为 T 的切片，其余类型为 T 的值将会追加到该切片的末尾
append 的结果是一个包含原切片所有元素加上新添加元素的切片
当 s 的底层数组太小，不足以容纳所有给定的值时，它就会分配一个更大的数组
返回的切片会指向这个新分配的数组

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=2 [0]

len=2 cap=2 [0 1]

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

Range

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

package main

import "fmt"

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

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

2**5 = 32

2**6 = 64

2**7 = 128

range（续）

可以将下标或值赋予 _ 来忽略它

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

若你只需要索引，忽略第二个变量即可

for i := range pow

package main

import "fmt"

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

输出

128

256

512

练习：切片

实现 `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 {
	a := make([][]uint8,dy)      // 外层切片
   for x := range a{
       b := make([]uint8,dx)   // 内层切片
       for y := range b{
           b[y] = uint8(x%(y+1))
        }
        a[x] = b  
    }
    return a
}

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

技术分享图片

映射

映射将键映射到值
映射的零值为 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}

映射的文法

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

package main

import "fmt"

type Vertex struct {
	Lat, Long float64
}

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

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

输出 map[Bell Labs:{40.68433 -74.39967} Google:{37.42202 -122.08408}]

映射的文法（续）

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

package main

import "fmt"

type Vertex struct {
	Lat, Long float64
}

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

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

修改映射

在映射 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"]
	fmt.Println("The value:", v, "Present?", ok)
}

练习：映射

实现 WordCount。它应当返回一个映射，其中包含字符串 s 中每个“单词”的个数。函数 wc.Test 会对此函数执行一系列测试用例，并输出成功还是失败

你会发现 strings.Fields 很有帮助

package main

import (
	"golang.org/x/tour/wc"
	"strings"
)

func WordCount(s string) map[string]int {
	strMap := make(map[string]int)
	for _, str := range strings.Fields(s) {
		_, ok := strMap[str]
		if ok {
			strMap[str] = strMap[str] + 1
		} else {
			strMap[str] = 1
		}
	}
	return strMap
}

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

函数值

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

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

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

函数的闭包

Go 函数可以是一个闭包
闭包是一个函数值，它引用了其函数体之外的变量。该函数可以访问并赋予其引用的变量的值，换句话说，该函数被这些变量“绑定”在一起
例如，函数 adder 返回一个闭包
每个闭包都被绑定在其各自的 sum 变量上

package main

import "fmt"

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 < 10; i++ {
		fmt.Println(
			pos(i),
			neg(-2*i),
		)
	}
}

练习：斐波纳契闭包

让我们用函数做些好玩的事情。

实现一个 fibonacci 函数，它返回一个函数（闭包），该闭包返回一个斐波纳契数列 `(0, 1, 1, 2, 3, 5, ...)

package main

import "fmt"

// 返回一个“返回int的函数”
func fibonacci() func() int {
   back1, back2:= 0, 1  // 预先设定好两个初始值
    return func() int {        
        temp := back1 //记录（back1）的值      
        back1,back2 = back2,(back1 + back2) // 重新赋值(这个就是核心代码)        
        return temp //返回temp
    } 
}

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

GoLang之旅（三）

原文：https://www.cnblogs.com/YC-L/p/12162540.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)

GoLang之旅（三）

指针

结构体

结构体字段

结构体指针

结构体文法

数组

切片

切片就像数组的引用

切片文法

切片的默认行为

切片的长度与容量

输出

nil 切片

用 make 创建切片

切片的切片

向切片追加元素

输出

Range

输出

range（续）

输出

练习：切片

实现 Pic

映射

映射的文法

映射的文法（续）

修改映射

练习：映射

函数值

函数的闭包

练习：斐波纳契闭包

实现 `Pic`