从实例学习 Go 语言,两天速通 Golang 的学习笔记及心得体会
2022/3/25 6:22:37
本文主要是介绍从实例学习 Go 语言,两天速通 Golang 的学习笔记及心得体会,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!
准备工作
为什么要从实例学习go语言?
我认为,从实例来学习一门编程语言,把编程语言各个重要的知识点通过例子展现出来,更加生动形象,对刚接触go语言的程序员来讲是最佳的选择。你不可能拿本编程宝典在那生啃是吧!肯定要动手参与敲代码的实践当中才有最好的学习效果。
为什么要写这篇文章?
记录我认为会比较容易忘记的知识点,适当补充,整理总结,以及自己的心得体会。适合初入go语言的小白和已经有部分go基础的复习参考。
学习地址
两个 Go 教程平台 github 项目地址
- https://github.com/Go-zh/tour
- https://github.com/gobyexample-cn/gobyexample
两个 Go 教程平台 部署地址(使用这个)
- https://tour.go-zh.org/basics/1
- https://gobyexample-cn.github.io/
如果文章字体过小,请调整浏览器页面缩放。Windows 按住 Ctrl + 鼠标滚轮
注意:本篇文章代码注释使用了 vscode 的 better-comments 拓展,具体请看
[个人配置] VSCode Better Comments 扩展配置、高亮注释插件
练习答案
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)) }
可以发现,无论运行多少次,第一次三个数字都是一样的,而第二次三个数字是变化的。
第一次 我最喜欢的数字 第一个数字 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 修饰符,只能在内部使用。
目录结构: └───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)) }
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 | 输出字符串,但转义符无效 |
%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("%v\n", p) fmt.Printf("%+v\n", p) fmt.Printf("%#v\n", p) fmt.Printf("%T\n", p) fmt.Printf("%t\n", true) fmt.Printf("%d\n", 123) fmt.Printf("%b\n", 14) fmt.Printf("%c\n", 33) fmt.Printf("%x\n", 456) fmt.Printf("%f\n", 78.9) fmt.Printf("%g\n", 78.9) // ^ 这个很好用 fmt.Printf("%e\n", 123400000.0) fmt.Printf("%E\n", 123400000.0) fmt.Printf("%s\n", "\"string\"") fmt.Printf("%q\n", "\"string\"") fmt.Printf("%x\n", "hex this") fmt.Printf("%p\n", &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 简短语句
同 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 elseif 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。
练习:平方根函数
题目地址:https://tour.go-zh.org/flowcontrol/8
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
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") }
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 拥有指针。指针保存了值的内存地址。
类型 *T
是指向 T
类型值的指针。其零值为 nil
。
&
操作符会生成一个指向其操作数的指针。即获取变量的内存地址
*
操作符表示指针指向的底层值。
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
)就是一组字段(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) }
{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) }
{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) }
Hello World [Hello World] [2 3 5 7 11 13]
切片 Slice
声明切片
每个数组的大小都是固定的。而切片则为数组元素提供动态大小的、灵活的视角。在实践中,切片比数组更常用。
[]T
表示一个元素类型为 T
的切片。
切片通过两个下标来界定,即一个上界和一个下界,二者以冒号分隔
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} }
截取默认行为
切片下界的默认值为 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) }
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], " ")) } }
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) }
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) } }
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) } }
1 2 4
练习:切片
题目地址:https://tour.go-zh.org/moretypes/18
实现 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) }
第二种写法
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
映射声明与使用
映射将键映射到值。
映射的零值为 nil
。nil
映射既没有键,也不能添加键。
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
中插入或修改元素:
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]
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
实现 WordCount
。它应当返回一个映射,其中包含字符串 s
中每个“单词”的个数。函数 wc.Test
会对此函数执行一系列测试用例,并输出成功还是失败。
你会发现 strings.Fields 很有帮助。
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.Since() 函数返回从 t 到现在经过的时间,等价于time.Now().Sub(t)
闭包
Go 函数可以是一个闭包。闭包是一个函数值,它引用了其函数体之外的变量。该函数可以访问并赋予其引用的变量的值,换句话说,该函数被这些变量“绑定”在一起。
例如,函数 adder
返回一个闭包。每个闭包都被绑定在其各自的 sum
变量上。
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), ) } }
0 0 1 -2 3 -6 6 -12
练习:斐波纳契闭包
题目地址:https://tour.go-zh.org/moretypes/26
// 返回一个“返回int的函数” func fibonacci() func() int { a,b,c := 0,1,0 return func() int{ c = a a,b = b,a+b return c } } func main() { f := fibonacci() for i := 0; i < 10; i++ { fmt.Println(f()) } }
0 1 1 2 3 5 8 13 21 34
面向对象
对象方法(值接收者)
Go 没有类。不过你可以为结构体类型定义方法。
方法就是一类带特殊的 接收者 参数的函数。通俗的来讲就是把方法绑定到这个结构体下。
方法接收者在它自己的参数列表内,位于 func
关键字和方法名之间。
在此例中,Abs
方法拥有一个名为 v
,类型为 Vertex
的接收者。
type Vertex struct { X, Y float64 } func (v Vertex) Abs() float64 { return math.Sqrt(v.X*v.X + v.Y*v.Y) } func main() { v := Vertex{3, 4} fmt.Println(v.Abs()) }
5
记住:方法只是个带接收者参数的函数。
你也可以为非结构体类型声明方法。我们对 float64
起一个别名 MyFloat
在此例中,我们看到了一个带 Abs
方法的数值类型 MyFloat
。
type MyFloat float64 func (f MyFloat) Abs() float64 { if f < 0 { return float64(-f) } return float64(f) } func main() { f := MyFloat(-math.Sqrt2) fmt.Println(f.Abs()) }
你只能为在同一包内定义的类型的接收者声明方法,而不能为其它包内定义的类型(包括 int
之类的内建类型)的接收者声明方法。
总结:接收者的类型定义和方法声明必须在同一包内;不能为内建类型声明方法。(所以上面为 float64
起了别名)
对象方法(指针接收者)
你可以为指针接收者声明方法。
这意味着对于某类型 T
,接收者的类型可以用 *T
的文法。(此外,T
不能是像 *int
这样的指针。)
例如,这里为 *Vertex
定义了 Scale
方法。
指针接收者的方法可以修改接收者指向的值(就像 Scale
在这做的)。由于方法经常需要修改它的接收者,指针接收者比值接收者更常用。
若使用值接收者,那么 Scale
方法会对原始 Vertex
值的副本进行操作。(对于函数的其它参数也是如此。)Scale
方法必须用指针接受者来更改 main
函数中声明的 Vertex
的值。
查看代码
type Vertex struct { X, Y float64 } func (v Vertex) Abs() float64 { return math.Sqrt(v.X*v.X + v.Y*v.Y) } func (v *Vertex) Scale(f float64) { v.X = v.X * f v.Y = v.Y * f } func main() { v := Vertex{3, 4} v.Scale(10) fmt.Println(v.Abs()) }
50
这篇关于从实例学习 Go 语言,两天速通 Golang 的学习笔记及心得体会的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!
- 2024-11-12Cargo deny安装指路
- 2024-11-02MongoDB项目实战:从入门到初级应用
- 2024-11-01随时随地一键转录,Google Cloud 新模型 Chirp 2 让语音识别更上一层楼
- 2024-10-25Google Cloud动手实验详解:如何在Cloud Run上开发无服务器应用
- 2024-10-24AI ?先驱齐聚 BAAI 2024,发布大规模语言、多模态、具身、生物计算以及 FlagOpen 2.0 等 AI 模型创新成果。
- 2024-10-20goland工具下,如修改一个项目的标准库SDK的版本-icode9专业技术文章分享
- 2024-10-17Go学习:初学者的简单教程
- 2024-10-17Go学习:新手入门完全指南
- 2024-10-17Golang学习:初学者入门教程
- 2024-10-17Golang学习:新手入门教程