Golang笔记2--基础语法
一个大的程序是由很多小的基础构件组成的。变量保存值，简单的加法和减法运算被组合成较复杂的表达式。基础类型被聚合为数组或结构体等更复杂的数据结构。然后使用if和for之类的控制语句来组织和控制表达式的执行流程。然后多个语句被组织到一个个函数中，以便代码的隔离和复用。函数以源文件和包的方式被组织
程序结构
命名
- Go命名规则：一个名字必须以一个字母（Unicode字母，所以中文也可）或下划线开头，后面可以跟任意数量的字母、数字或下划线
- Keyword: 不能用于自定义名字
break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var
- 预定义的名字: 可重新定义
内建常量: true false iota nil
内建类型: int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64 complex128 complex64
bool byte rune string error
内建函数: make len cap new append copy close delete
complex real imag
panic recover
- 头字母的大小写决定了名字在包外的可见性: 大写开头(函数外定义)可以被外部的包访问
- Go语言风格是尽量使用短小的名字,尤其局部变量, 个人认为如影响理解则用具有意义的长命名
- Go语言程序员推荐使用驼峰式命名,缩写全大写
const lowerhex = "0123456789abcdef"
//QuoteRuneToASCII ...
func QuoteRuneToASCII(r rune) string
func appendQuotedRuneWith(buf []byte, r rune, quote byte, ASCIIonly, graphicOnly bool) []byte
- Go lint工具可帮助检测命名是否合规
声明
声明语句定义了程序的各种实体对象以及部分或全部的属性. Go语言主要有四种类型的声明语句：var、const、type和func，分别对应变量、常量、类型和函数实体对象的声明
- Go源文件以
go作为后缀, 以包声明开始 - 之后
import导入依赖的包 - 包级的类型、变量、常量、函数的声明，无顺序(函数内必须先声明)
package main
// 单行
// import "time"
// import log "github.com/sirupsen/logrus"
// 或者:
import(
"time"
// third-party包, 别名: log
log "github.com/sirupsen/logrus"
)
const version = "0.0.1"
// Printer is a exported struct
type Printer struct {
name string
}
//Print is a exported method
func(p *Printer) Print(){
_ = printTime(time.Now()) //nolint
}
// 函数
func printTime(t time.Time) error{
log.Info("now time: ", time.Now(), " version: ", version)
return nil
}
// 主函数
func main() {
var printer Printer
printer.Print()
}
-
函数的声明
-
func关键字 - 函数名字：
printTime - 形参列表(变量名 变量类型, 可选, 由调用者提供实参):
t time.Time - 返回值列表(可选, 多个需用括号):
error - 函数体, 花括号内:
{...} - struct方法还包含
receiver:(p *Printer)
-
变量
-
var 变量名字 类型 = 表达式, 未提供初始值则自动用零值初始化:var printer Printer - 简洁方式,冒号等号(无冒号则为赋值操作):
name := "tester",printer := Printer{} - 多个变量:
var i,j,k int
var b, f, s = true, 2.3, "four" // bool, float64, string
var f, err = os.Open(name) //函数返回多个值
i, j := 0, 1
// 无冒号则为赋值操作
i, j = j, i // 交换 i 和 j 的值
指针变量
- 一个指针的值是另一个变量的地址，
- 通过指针，我们可以直接读或更新对应变量的值
- 对于
var x int声明的变量x, 那么&x(取x变量的内存地址)将产生一个指向x的指针 - 该指针对应的数据类型是
*int - 指针零值都是
nil - 返回函数中局部变量的地址也是安全的(自动垃圾回收机制)
- 指针示例：标准库中flag包的关键技术，它使用命令行参数来设置对应变量的值
package main
import (
"flag"
"fmt"
"strings"
)
// flag.Bool函数会创建对应标志参数的变量:
// 三个属性：名字“n”，默认值（这里是false），最后是描述信息
var n = flag.Bool("n", false, "omit trailing newline")
var sep = flag.String("s", " ", "separator")
func main() {
flag.Parse()
fmt.Print(strings.Join(flag.Args(), *sep))
if !*n {
fmt.Println()
}
}
- new内置函数
- 语法糖, 表达式new(T)将创建一个T类型的匿名变量
- 初始化为T类型的零值
- 返回变量地址，返回的指针类型为*T
变量生命周期和作用域
- 包变量贯穿整个程序运行周期(运行时)
- 部变量是动态的, 声明到不再被引用
- 作用域是指源代码中可以有效使用名字的范围(编译时概念)
- 句法块是由花括弧所包含的一系列语句,块内局部变量不能被块外部访问
- 内置类型(int,float等),内置函数, 常量等作用域全局，任何地方可用
- 控制流标号，就是break、continue或goto语句后标号，则是函数级的作用域
赋值
- 使用
=号, 复合赋值:x *= scale相当于x = x * scale - 元组赋值:
x, y = y, x交换x,y - 多个返回值赋值
f, err = os.Open("foo.txt")- 这类函数会用额外的返回值来表达某种错误类型或bool判断
- 用下划线空白标识符_来丢弃不需要的值
// 后续了解
v, ok = m[key] // map lookup
v, ok = x.(T) // type assertion
v, ok = <-ch // channel receive
v = m[key] // map查找，失败时返回零值
_, exists := m[key] // _占位
- 可赋值性
- 隐式赋值:
medals := []string{"gold", "silver", "bronze"} - 只有右边的值对于左边的变量是可赋值的，赋值语句才是允许的
- 隐式赋值:
类型
type 类型名字 底层类型- 命名类型还可以为该类型的值定义新的行为(方法集)
- 对于类型T, 都有一个对应的类型转换操作T(x), 若T为指针可能还需要小括号:
(*int)(0) - string []byte可转换，数值可转换
type Celsius float64 // 摄氏温度
type Fahrenheit float64 // 华氏温度
func(c Celsius) String() string{
return fmt.Sprintf("%g°C", c)
}
var c Celsius
var f Fahrenheit
fmt.Println(c == 0) // "true"
fmt.Println(f >= 0) // "true"
fmt.Println(c == f) // compile error: type mismatch
fmt.Println(c == Celsius(f)) // "true"!
控制流结构
gpl并没有专门章节讲解基本控制流, 这里简单列举下吧.
- if条件语句, 跟c/c++比条件不需要括号
// condition 为真，否则
if condition {
...
} else {
...
}
// 惯用一
if ok:= function(); ok {
...
}
// 惯用二, 判定是否出错
if val, err:= function(); err!=nil {
...
}
- switch语句
switch x := 0; x {
case 0:
fmt.Println(0)
case 1:
fallthrough
default:
fmt.Println("other")
}
// 不止是整型
switch coinflip() {
case "heads":
heads++
case "tails":
tails++
default:
fmt.Println("landed on edge!")
}
// 无tag, 表达式
func Signum(x int) int {
switch {
case x > 0:
return +1
default:
return 0
case x < 0:
return -1
}
}
- 循环语句, 不用小括号, 其他跟C/C++类似
i := 0
for ; i < 10; {
i++
}
// or
for i:=0; i<10; i++ {
}
// 无限循环
for {
}
//slice、数组的range迭代
for i,value:=range someSlice {
//...
}
//map range迭代
for k,v:=range someMap {
...
}
-
goto,break和continue,
// goto语句可以无条件地转移到过程中指定的行
if condition {
goto End
}
End:
close(xxx)
//跳出内层循环，不在执行循环
for {
if condition {
break
}
}
// continue 继续下一次迭代
for {
if condition {
continue
}
// other states skipped
}
// 跳出外层循环, 使用Label
OutLoop:
for {
for i:=0; i<10;i++ {
if condition {
break OutLoop
}
}
}
-
select多路复用,在select阻塞, 随机选择一个消息到达的case执行,详细见后续并发章节
//for-select
Loop:
for {
select {
case v, ok:=<-someChan:
if !ok {
break Loop
}
//...
case time.After(time.Second):
break Loop
}
}
包和文件
- 包是为了支持模块化、封装、单独编译和代码重用
- 每个包都对应一个独立的名字空间, 引用时加包名:
fmt.Println - 名字大写字母开头是从包中导出, 外部可调用
- 文件以
package xxx开头, xxx包 - 倒入包:
import xxx - 包初始化解决包级变量的依赖顺序, 按声明顺序初始化, 多个文件按字母序发给编译器
- 包初始化函数:
func init(), 每个源文件可定义多个(建议1个), 不能被用户调用或引用 - 在解决依赖情况下以导入声明的顺序初始化, main包最后初始化
基础数据类型
数字、字符串和布尔型。复合数据类型——数组和结构体
整型
- 算术、逻辑和比较运算符(按优先级递减)
* / % << >> & &^
+ - | ^
== != < <= > >=
&&
||
- 一元加减法(正负号)
+ 一元加法 (无效果)
- 负数
- 位操作符
& 位运算 AND
| 位运算 OR
^ 位运算 二元操作符 XOR, 一元操作符为取反
&^ 位清空 (AND NOT)
<< 左移
>> 右移
浮点数
- math.MaxFloat32表示float32能表示的最大数值，大约是 3.4e38
- math.MaxFloat64常量大约是1.8e308
- %g, %f, %e(带指数)
fmt.Printf("%8.3f\n", math.Exp(float64(x))) - math.IsNaN()
- 正无穷大和负无穷大，分别用于表示太大溢出的数字和除零的结果；还有NaN非数，一般用于表示无效的除法操作结果0/0或Sqrt(-1)
var z float64
fmt.Println(z, -z, 1/z, -1/z, z/z) // "0 -0 +Inf -Inf NaN"
复数
提供两种精度复数: complex64和complex128
布尔型
不能直接和整型0, 1转换
字符串
- 一个字符串是一个不可改变的字节序列
- 文本字符串通常被解释为采用UTF8编码的Unicode码点（rune）序列
- len函数可以返回字符串中的字节数目（不是rune字符数目, rune是int32等价类型）
- 利用UTF8编码, UTF8是一个将Unicode码点编码为字节序列的变长编码(1-4Bytes)
- 转义,\uhhhh对应16bit的码点值，\Uhhhhhhhh对应32bit
import "unicode/utf8"
w := "世界"
// "\xe4\xb8\x96\xe7\x95\x8c"
// "\u4e16\u754c"
// "\U00004e16\U0000754c"
s := "Hello, 世界"
fmt.Println(len(s)) // "13"
fmt.Println(utf8.RuneCountInString(s)) // "9"
for i := 0; i < len(s); {
r, size := utf8.DecodeRuneInString(s[i:])
fmt.Printf("%d\t%c\n", i, r)
i += size
}
fmt.Println(string(65)) // "A", not "65"
fmt.Println(string(0x4eac)) // "京"
标准库中有四个包对字符串处理尤为重要：bytes、strings、strconv和unicode包
- 数字字符串转换,
strconv
import "strconv"
x := 123
y := fmt.Sprintf("%d", x)
fmt.Println(y, strconv.Itoa(x)) // "123 123"
x, err := strconv.Atoi("123") // x is an int
y, err := strconv.ParseInt("123", 10, 64) // base 10, up to 64 bits
- 字符串处理函数,
strings:Contains,Split等
常量
const pi = 3.14159265358979323846264338327950288419716939937510582097494459- 常量声明可以使用
iota常量生成器初始化
const (
_ = 1 << (10 * iota)
KiB // 1024
MiB // 1048576
GiB // 1073741824
TiB // 1099511627776 (exceeds 1 << 32)
PiB // 1125899906842624
EiB // 1152921504606846976
ZiB // 1180591620717411303424 (exceeds 1 << 64)
YiB // 1208925819614629174706176
)
复合数据类型
数组
- 元素个数明确指定, 可以用省略号(由初始化值个数决定)
var a [3]int
var a [...]int={1,2,3}
r := [...]int{99: -1} //100 items
- 实际示例: crypto/sha256包的Sum256函数对一个任意的字节slice类型的数据生成一个对应的消息摘要。消息摘要有256bit大小，因此对应[32]byte数组类型
切片slice
- slice（切片）代表变长的序列: []T,不指定元素个数
- 一个slice是一个轻量级的数据结构，提供了访问数组子序列
- 切片操作
s[i:j],[3:],[:3],[:]所有元素
- 切片操作
- 内置函数
make, 创建一个匿名数组，返回一个slice -
cap容量 - 内置函数
append, 向slice追加元素, 可用于nil, 可追加多个元素，甚至追加一个slice - 两slice不能直接比较相等, bytes.Equal函数判断两个字节型slice是否相等([]byte)
make([]T, len)
make([]T, len, cap) // same as make([]T, cap)[:len]
// append
var s,ss []string
s = append(s, 'a')
ss = append(ss, s...)
- 类似于:
type IntSlice struct {
ptr *int
len, cap int
}
map
哈希表是一个无序的key/value对的集合，key唯一，通过给定的key可以在常数时间复杂度内检索、更新或删除对应的value, map类型的零值是nil
// 创建，`make`可创建map
ages1 := make(map[string]int)
ages1["alice"] = 32
ages2 := map[string]int{
"alice": 31,
"charlie": 34,
}
// 删除对应key元素
delete(ages, "alice")
// 是否存在
if _, exists:= ages2["alice"]; exists{
fmt.Println("exists")
}
// access
ages["bob"]++
// range遍历
for k, v:=range ages2{
fmt.Println(k,v)
}
- map中的元素并不是一个变量，因此我们不能对map的元素进行取址操作(因为地址会变)
- 不能直接相等, 要判断两个map是否包含相同的key和value，要通过循环实现
- 类似集合可以使用
map[T]bool实现 - map和slice参数传引用
结构体
- 结构体由零个或多个任意类型的值聚合而成, 每个值称为结构体的成员
- 成员的输入顺序有意义(如以下
Name,Address不同顺序则为不同结构体) - 考虑效率的话，较大的结构体通常会用指针的方式传入和返回
- 如果所有成员可比较, 则结构体可以比较(==, !=),且可用作map的key
- 结构体类型的零值是每个成员都是零值(第9章sync.Mutex零值为未锁定状态)
// 一般一行对应一个成员，也可以合并, 成员名字在前,类型在后
type Employee struct {
ID int
Name,Address string
}
var dilbert Employee
- S类型的结构体可以包含*S指针类型的成员, 如以下二叉树实现插入排序
type tree struct {
value int
left, right *tree
}
// Sort sorts values in place.
func Sort(values []int) {
var root *tree
for _, v := range values {
root = add(root, v)
}
appendValues(values[:0], root)
}
// appendValues appends the elements of t to values in order
// and returns the resulting slice.
func appendValues(values []int, t *tree) []int {
if t != nil {
values = appendValues(values, t.left)
values = append(values, t.value)
values = appendValues(values, t.right)
}
return values
}
func add(t *tree, value int) *tree {
if t == nil {
// Equivalent to return &tree{value: value}.
t = new(tree)
t.value = value
return t
}
if value < t.value {
t.left = add(t.left, value)
} else {
t.right = add(t.right, value)
}
return t
}
- 结构体字面值, 注意: 以下两种方式不能混用, 且不能对未导出成员使用
type Point struct{ X, Y int }
// 按照顺序
p := Point{1, 2}
// 指定成员名字
anim := gif.GIF{LoopCount: nframes}
- 较大的结构体通常会用指针的方式传入和返回
- 如果要在函数内部修改结构体成员的话，必须指针传入, 因为Go函数传值调用
pp := &Point{1, 2}
// 等价于
pp := new(Point)
*pp = Point{1, 2}
- 结构体嵌入和匿名成员, 可简化编程, 简单实现继承, 看以下圆和轮的演进:
// 原始版本
type Circle struct {
X, Y, Radius int
}
type Wheel struct {
X, Y, Radius, Spokes int
}
相同属性独立出来, 便于维护
type Point struct {
X, Y int
}
type Circle struct {
Center Point
Radius int
}
type Wheel struct {
Circle Circle
Spokes int
}
但是访问繁琐:
w.Circle.Center.X = 8
w.Circle.Center.Y = 8
结构体内只声明数据类型而不指名成员名,这类成员就叫匿名成员
type Circle struct {
Point
Radius int
}
type Wheel struct {
Circle
Spokes int
}
这样访问成员(显式形式访问这些内部成员的语法依然有效):
var w Wheel
// 快捷方式
w.X = 8 // equivalent to w.Circle.Point.X = 8
w.Y = 8 // equivalent to w.Circle.Point.Y = 8
w.Radius = 5 // equivalent to w.Circle.Radius = 5
w.Spokes = 20
但字面值定义需要遵循层次:
w = Wheel{Circle{Point{8, 8}, 5}, 20} //or
w = Wheel{
Circle: Circle{
Point: Point{X: 8, Y: 8},
Radius: 5,
},
Spokes: 20, // NOTE: trailing comma necessary here (and at Radius)
}
fmt.Printf("%#v\n", w)
注意:
- fmt的
%#v将打印成员名，不止于值 - 因为有隐式的名字, 不能同时包含两个类型相同的匿名成员
- 包外使用时, 未导出成员无法用简化方式访问
json
标准库中的encoding/json、encoding/xml、encoding/asn1等包提供支持, 另外还有大量第三方json库可用(protobuf的jsonpb,jsoniter...)
- 基本类型有数字(int, float),布尔型(true,false), 字符串(双引号包含的unicode字符序列)
- 复合类型, 数组(可编码Golang的数组和slice), 对象(可编码Golang的map和结构体)
- struct定义中成员之后反引号的tag可定义json
type Movie struct {
Title string
Year int `json:"released"`
Color bool `json:"color,omitempty"`
Actors []string
}
struct转换为json的过程叫编码(marshaling):
data, err := json.Marshal(movies)
if err != nil {
log.Fatalf("JSON marshaling failed: %s", err)
}
fmt.Printf("%s\n", data)
输出无缩紧，难以阅读(注意: 在最后一个成员或元素后面并没有逗号分隔符)：
[{"Title":"Casablanca","released":1942,"Actors":["Humphrey Bogart","Ingr
id Bergman"]},{"Title":"Cool Hand Luke","released":1967,"color":true,"Ac
tors":["Paul Newman"]},{"Title":"Bullitt","released":1968,"color":true,"
Actors":["Steve McQueen","Jacqueline Bisset"]}]
因此，还可以使用：
data, err := json.MarshalIndent(movies, "", " ")
//...
- 编码的逆操作是解码，对应将JSON数据解码为Go语言的数据结构(unmarshaling)
var titles []struct{ Title string }
if err := json.Unmarshal(data, &titles); err != nil {
log.Fatalf("JSON unmarshaling failed: %s", err)
}
fmt.Println(titles) // "[{Casablanca} {Cool Hand Luke} {Bullitt}]"
- GitHub的Web服务接口
- 摘录译文版两段说明:
基本的JSON类型有数字（十进制或科学记数法）、布尔值（true或false）、字符串，其中字符串是以双引号包含的Unicode字符序列，支持和Go语言类似的反斜杠转义特性，不过JSON使用的是\Uhhhh转义数字来表示一个UTF-16编码（译注：UTF-16和UTF-8一样是一种变长的编码，有些Unicode码点较大的字符需要用4个字节表示；而且UTF-16还有大端和小端的问题），而不是Go语言的rune类型。
这些基础类型可以通过JSON的数组和对象类型进行递归组合。一个JSON数组是一个有序的值序列，写在一个方括号中并以逗号分隔；一个JSON数组可以用于编码Go语言的数组和slice。一个JSON对象是一个字符串到值的映射，写成以系列的name:value对形式，用花括号包含并以逗号分隔；JSON的对象类型可以用于编码Go语言的map类型（key类型是字符串）和结构体
文本和HTML模板
text/template和html/template提供模板相关支持
一个模板是一个字符串或一个文件，里面包含了一个或多个由双花括号包含的{{action}}对象
const templ = `{{.TotalCount}} issues:
{{range .Items}}----------------------------------------
Number: {{.Number}}
User: {{.User.Login}}
Title: {{.Title | printf "%.64s"}}
Age: {{.CreatedAt | daysAgo}} days
{{end}}`
func daysAgo(t time.Time) int {
return int(time.Since(t).Hours() / 24)
}
- action中
|操作符表示将前一个表达式的结果作为后一个函数的输入，类似于UNIX中管道 - 生成模板的输出的处理步骤:
- 第一步是要分析模板(执行一次即可)并转为内部表示
- 然后基于指定的输入执行模板
// 调用链顺序：
// template.New先创建并返回一个模板；
// uncs方法将daysAgo等自定义函数注册到模板中，并返回模板；
// 最后调用Parse函数分析模板
report, err := template.New("report").
Funcs(template.FuncMap{"daysAgo": daysAgo}).
Parse(templ)
if err != nil {
log.Fatal(err)
}
- 模板解析失败是致命错误(编译前测试好), template.Must辅助函数可以简化处理
// 模板解析失败是致命错误(编译前测试好), template.Must辅助函数可以简化处理
var report = template.Must(template.New("issuelist").
Funcs(template.FuncMap{"daysAgo": daysAgo}).
Parse(templ))
func main() {
result, err := github.SearchIssues(os.Args[1:])
if err != nil {
log.Fatal(err)
}
if err := report.Execute(os.Stdout, result); err != nil {
log.Fatal(err)
}
}
-
html/template模板包类似, 但是增加了字符串自动转义特性- 避免输入字符串和HTML、JavaScript、CSS或URL语法产生冲突的问题
- 避免一些安全问题，诸如HTML注入攻击
import "html/template"
var issueList = template.Must(template.New("issuelist").Parse(`
<h1>{{.TotalCount}} issues</h1>
<table>
<tr style='text-align: left'>
<th>#</th>
<th>State</th>
<th>User</th>
<th>Title</th>
</tr>
{{range .Items}}
<tr>
<td><a href='{{.HTMLURL}}'>{{.Number}}</a></td>
<td>{{.State}}</td>
<td><a href='{{.User.HTMLURL}}'>{{.User.Login}}</a></td>
<td><a href='{{.HTMLURL}}'>{{.Title}}</a></td>
</tr>
{{end}}
</table>
`))
函数
声明(见前)
- 函数声明包括函数名、形参列表、返回值列表（可省略）以及函数体
func name(parameter-list) (result-list) {
body
}
- 函数的类型被称为函数的标识符, 形参和返回值类型一一对应被认为有相同的类型和标识符
type HandleFunc func(http.ResponseWriter, *http.RequestReader)
- 函数可递归，即可直接或间接地调用自身
- Golang函数可多值返回, 小括号包含
- 返回值可指定变量名, 相同类型指定有意义的命名可增加可读性
// width, height
func Size(rect image.Rectangle) (width, height int)
错误
- 函数返回一个额外的返回值，通常是最后一个，来传递错误信息(
error)。如果导致失败的原因只有一个，额外的返回值可以是一个布尔值(bool) - 通常，当函数返回
non-nil的error时，其他返回值是未定义的(undefined),应该被忽略 - 某些情况其他值可返回有意义值, 如文件读写失败, 仍然会返回读写字节数， 这种情况应该是先处理不完整的数据，再处理错误
- EOF错误, 由文件读取结束引发的读取失败
关于不使用异常的说明:
Go这样设计的原因是由于对于某个应该在控制流程中处理的错误而言，将这个错误以异常的形式抛出会混乱对错误的描述，这通常会导致一些糟糕的后果
错误处理策略
- 向上传播
- 描述详尽, 包含上下文
- 错误信息经常是以链式组合在一起的，所以错误信息中应避免
大写和换行符
- 重试策略
- 偶然性的
- 或由不可预知的问题导致
- 输出错误信息并结束程序
- main函数
- 程序内部包含不一致，即bug导致
- log.Fatal
- 仅打印信息，不中断不重试
- 直接忽略策略
函数值
被看作第一类值（first-class values）：函数像其他值一样，拥有类型，可以被赋值给其他变量，传递给函数，从函数返回
- 函数类型的零值是nil, 可与nil比较，nil调用会
panic - 函数值之间不可比较, 不能用函数值作为map的key
- 匿名函数: func关键字后没有函数名, 绕过函数只能在包级别定义的限制
// 匿名函数
add1:= func(r rune) rune { return r + 1 }
fmt.Println(strings.Map(add1, "VMS")) // "WNT"
fmt.Println(strings.Map(func(r rune)rune {
return r + 1
}, "VMS")
警告：匿名函数捕获迭代变量
循环迭代中，函数值中记录的迭代变量(作用域在for词法块，在该循环中生成的所有函数值都共享相同的循环变量)地址而不是值
注意以下赋值: dir := d
var rmdirs []func()
for _, d := range tempDirs() {
dir := d // NOTE: necessary!
os.MkdirAll(dir, 0755) // creates parent directories too
rmdirs = append(rmdirs, func() {
os.RemoveAll(dir)
})
}
// ...do some work…
for _, rmdir := range rmdirs {
rmdir() // clean up
}
后续遇到defer语句或for循环中goroutine(go func(){...})类似!!!
可变参数
unc sum(vals...int) int {
total := 0
for _, val := range vals {
total += val
}
return total
}
后续会遇到可变option个数传递
deferred函数
defer someFuncion()- 在包含该defer语句的函数其他语句完毕后才执行
- 多个defer后来先执行
- defer语句经常被用于处理成对的操作，如打开、关闭、连接、断开连接、加锁、释放锁
- 通过defer机制保证在任何执行路径下，资源被释放
- 释放资源的defer应直接跟在请求资源的语句后
func title(url string) error {
resp, err := http.Get(url)
if err != nil {
return err
}
defer resp.Body.Close()
ct := resp.Header.Get("Content-Type")
if ct != "text/html" && !strings.HasPrefix(ct,"text/html;") {
return fmt.Errorf("%s has type %s, not text/html",url, ct)
}
doc, err := html.Parse(resp.Body)
if err != nil {
return fmt.Errorf("parsing %s as HTML: %v", url,err)
}
// ...print doc's title element…
return nil
panic和recover
当panic异常发生时，程序会中断运行，并立即执行在该goroutine（可以先理解成线程，在第8章会详细介绍）中被延迟的函数（defer 机制）。随后，程序崩溃并输出日志信息
- 直接调用内置的panic函数也会引发panic异常, 到达逻辑上不可达的路径可以panic
- panic会引起程序的崩溃，因此一般用于严重错误，如程序内部的逻辑不一致
- 明确正则表达式(大多数是字符串字面值)不会出错,可使用
regexp.MustCompile检查输入
通常来说，不应该对panic异常做任何处理，但有时，也许我们可以从异常中恢复，至少我们可以在程序崩溃前，做一些操作。举个例子，当web服务器遇到不可预料的严重问题时，在崩溃前应该将所有的连接关闭；如果不做任何处理，会使得客户端一直处于等待状态
如果在deferred函数中调用了内置函数recover，并且定义该defer语句的函数发生了panic异常，recover会使程序从panic中恢复，并返回panic value。导致panic异常的函数不会继续运行，但能正常返回。在未发生panic时调用recover，recover会返回nil。
deferred函数帮助Parse从panic中恢复。在deferred函数内部，panic value被附加到错误信息中；并用err变量接收错误信息，返回给调用者。我们也可以通过调用runtime.Stack往错误信息中添加完整的堆栈调用信息。
func Parse(input string) (s *Syntax, err error) {
defer func() {
if p := recover(); p != nil {
err = fmt.Errorf("internal error: %v", p)
}
}()
// ...parser...
}
注意: 不应该试图去恢复其他包引起的panic(有时难以做到)，安全的做法是有选择性的recover
方法
- 方法是一个和特殊类型关联的函数, 面向对象编程概念.
- 方法关联一个被称为接收器的对象
- 指针对象可避免复制, 可修改成员变量, 否则修改复制对象的成员，改不了原来的对象
- 不管receiver是指针类型还是非指针类型，都可以通过指针/非指针类型进行调用的，编译器会根据方法自动转换
- Nil也是一个合法的接收器类型
通过嵌套struct继承方法
- 嵌入的struct方法可以被重新定义, 外部结构在其方法可以显式调用嵌入对象的方法
func (p *Point) ScaleBy(factor float64) {
p.X *= factor
p.Y *= factor
}
示例： sync.Mutex的Lock和Unlock方法被引入到匿名结构中:
var cache = struct {
sync.Mutex
mapping map[string]string
}{
mapping: make(map[string]string),
}
func Lookup(key string) string {
cache.Lock()
v := cache.mapping[key]
cache.Unlock()
return v
}
方法值和方法表达式
distanceFromP := p.Distance // method value
fmt.Println(distanceFromP(q)) // "5"
bitmap
通常使用map[T]bool来表示集合, 但是用bitmap(byte[]实现)是种更好的选择:
- 例如在数据流分析领域, 集合通常是非负整数
- http分块下载文件(16KB每块)，可用bimap标记下载完成的块
// An IntSet is a set of small non-negative integers.
// Its zero value represents the empty set.
type IntSet struct {
words []uint64
}
// Has reports whether the set contains the non-negative value x.
func (s *IntSet) Has(x int) bool {
word, bit := x/64, uint(x%64)
return word < len(s.words) && s.words[word]&(1<<bit) != 0
}
// Add adds the non-negative value x to the set.
func (s *IntSet) Add(x int) {
word, bit := x/64, uint(x%64)
for word >= len(s.words) {
s.words = append(s.words, 0)
}
s.words[word] |= 1 << bit
}
// UnionWith sets s to the union of s and t.
func (s *IntSet) UnionWith(t *IntSet) {
for i, tword := range t.words {
if i < len(s.words) {
s.words[i] |= tword
} else {
s.words = append(s.words, tword)
}
}
}
// String returns the set as a string of the form "{1 2 3}".
func (s *IntSet) String() string {
var buf bytes.Buffer
buf.WriteByte('{')
for i, word := range s.words {
if word == 0 {
continue
}
for j := 0; j < 64; j++ {
if word&(1<<uint(j)) != 0 {
if buf.Len() > len("{") {
buf.WriteByte(' ')
}
fmt.Fprintf(&buf, "%d", 64*i+j)
}
}
}
buf.WriteByte('}')
return buf.String()
}
注意: bytes.Buffer的String()用法, 定义Strin()有助于fmt.Print会调用打印, 这种机制有赖于接口和类型断言(详见下一章)
封装
OOB编程很重要的一点就是封装(信息隐藏), 三个好处:
- 最少知识: 无需调用方了解所有细节, 仅需少量接口即可
- 依赖抽象: 隐藏实现的细节，可以防止调用方依赖那些可能变化的具体实现
- 防止外部调用方对对象内部的值任意地进行修改
回顾上一节的IntSet定义:
type IntSet struct {
words []uint64
}
其实也可以这样定义:
type IntSet []uint64
但是后者封装性不如前者, 因为words成员是包外不可见的, 无法直接操作
封装并不总是需要的, 比如time包的Duration暴露为int64的纳秒, 这样自定义相关常量成为可能:
const day = 24 * time.Hour
另外如第二种方式暴露内部slice成员, 就可以直接用range迭代
网友评论