或者叫"特别的写法"
包的引入
不建议相对路径,应该是
import "xxx.com/pro/net"
循环
1
2
3
4 // Reverse a
for i, j := 0, len(a)-1; i < j; i, j = i+1, j-1 {
a[i], a[j] = a[j], a[i]
}switch
switch里可以写表达式的,
case 值可以写多个的.
和for一起,break 的问题,break跳转到loop
1 | Loop: |
循环中的跳转 continue loop
type,针对interface{} 类型
1 | var t interface{} |
os.Getenv os.Stdout
Sprintf Fprintf
断言与类型转换
interface
1
2
3
4
5
6
7
8
9
10
11type Stringer interface {
String() string
}
var value interface{} // Value provided by caller.
switch str := value.(type) {
case string:
return str
case Stringer:
return str.String()
}一般类型判断
1
2
3
4
5
6str, ok := value.(string)
if ok {
fmt.Printf("string value is: %q\n", str)
} else {
fmt.Printf("value is not a string\n")
}
1 | if str, ok := value.(string); ok { |
用于调试的空变量,调试的包导入写法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package main
import (
"fmt"
"io"
"log"
"os"
)
var _ = fmt.Printf // For debugging; delete when done.
var _ io.Reader // For debugging; delete when done.
func main() {
fd, err := os.Open("test.go")
if err != nil {
log.Fatal(err)
}
// TODO: use fd.
_ = fd
}runtime.NumCPU runtime.GOMAXPROCS
Recover
用来捕捉runtime的异常,禁止滥用,在开发测试阶段尽量不用,一般放在认为会有不可预期的异常的地方.
1 | func server(workChan <-chan *Work) { |
方法接收器
名称 一般采用strcut的第一个字母且为小写,而不是this,me或者self1
2type T struct{}
func (p *T)Get(){}
如果接收者是map,slice或者chan,不要用指针传递1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40//Map
package main
import (
"fmt"
)
type mp map[string]string
func (m mp) Set(k, v string) {
m[k] = v
}
func main() {
m := make(mp)
m.Set("k", "v")
fmt.Println(m)
}
//Channel
package main
import (
"fmt"
)
type ch chan interface{}
func (c ch) Push(i interface{}) {
c <- i
}
func (c ch) Pop() interface{} {
return <-c
}
func main() {
c := make(ch, 1)
c.Push("i")
fmt.Println(c.Pop())
}
如果需要对slice进行修改,通过返回值的方式重新赋值1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18//Slice
package main
import (
"fmt"
)
type slice []byte
func main() {
s := make(slice, 0)
s = s.addOne(42)
fmt.Println(s)
}
func (s slice) addOne(b byte) []byte {
return append(s, b)
}
如果接收者是含有sync.Mutex或者类似同步字段的结构体,必须使用指针传递避免复制1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25package main
import (
"sync"
)
type T struct {
m sync.Mutex
}
func (t *T) lock() {
t.m.Lock()
}
/*
Wrong !!!
func (t T) lock() {
t.m.Lock()
}
*/
func main() {
t := new(T)
t.lock()
}
如果接收者是大的结构体或者数组,使用指针传递会更有效率。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18package main
import (
"fmt"
)
type T struct {
data [1024]byte
}
func (t *T) Get() byte {
return t.data[0]
}
func main() {
t := new(T)
fmt.Println(t.Get())
}