GO语言基础必知必会
博主学习时总结的一些基础知识点。拿捏！
1. 应用程序入口
- 必须是 main 包： package main
- 必须是 main 方法： func main()
- 文件名不一定是 main.go
2. 命令行参数接收
- 使用 os 包下面的 os.Args 参数
- 且下标从 1 开始
3.编写测试程序
- 文件包名为 xxx_test
- 文件名为 xxx_test.go
- 方法名为首字符大写 Test 开头，且形参为 t *testing.T
4.变量命名和赋值
一个名字必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线。大写字母和小写字母是不同的
var a int = 1
var b int = 2
// 也可以依赖自动类型判断
var a = 1
var b = 2
// 也可以批量赋值
var (
a int = 1
b int = 2
c = 1
d = 2
)
// 还可以更简单的下
a:=1
b:=2
// 还可以这样批量赋值【元组赋值】
a:=1
b:=2
// 交换两个的值
a,b = b,a
5.常量定义
const (
one = 1
two = 2
three = 3
)
// 等效于
const(
one = ital + 1
two
three
)
const(
Readable = 1 << iota //0001
Writeable //0010
Executable // 0100
)
6.数据类型
Go语言将数据类型分为四类：
6.1 基础类型
- 数字
- 字符串
- 布尔型
6.2 复合类型
- 数组
- 结构体
6.3 引用类型
- 指针
- 切片
- 字典
- 函数
- 通道
6.4 接口类型
bool
string
int int8 int16 int32 int64
unit unit8 unit16 unit32 unit64 unitptr
byte //等同于unit8
rune // 等同 int32 unitcode编码指针
float32 float64
complex64 complex128
- go 语言不支持隐式的类型转换
- 别名和原有类型也不能进行隐式的转换
- 字符串的默认值是空字符串不是nil
- 指针不支持运算(比如说+1)
string 是只读的 byte slice ，len 函数可以计算它所包含的 byte 数， string 的 byte 数组可以存放任何数据
7.运算符
- 没有前置++ 和前置–
- 数组的比较(==)必须是相同类型且相同元素个数，否则会报错
8.条件和循环
// 普通循环
n:= 0
for n < 5 {
n++
fmt.PrintLn(n)
}
//普通循环三次
for n:=0; n < 3; n++ {
}
// 无限循环
n := 0
for {
...
}
// 条件语句
if n==5 {
}
//多判断，函数支持多个返回值
if result,err := someThing(); err == nil {
}
//switch 使用，支持case 后面接多个值，且不用带 break
i:=32
switch i {
case 1:
t.Log(1)
case 2,32:
t.Log(32)
default:
t.Log(3)
}
9. 函数
// 支持多返回值
func test(a string, b *T) (result string, err error) {
return "ok", nil
}
a, err := test("a", &b);
if (err != nil) {
return err;
}
// 匿名函数
func squares() func() int {
var x int
return func() int {
x++
return x * x
}
}
//可变参数
func sum(vals ...int) int {
total := 0
for _, val := range vals {
total += val
}
return total
}
// 延迟函数，执行顺序和声明相反
defer resp.Body.Close()
func timeSpent(inner func (op int) int) func(op int) int {
return func (n int) int {
start := time.Now()
ret := inner(n)
fmt.Println("time spent", time.Since(start).Seconds())
return ret
}
}
func slowFun(op int) int {
time.Sleep(time.Second * 1)
return op
}
ts := timeSpent(slowFun)
ts(10)
10 接口
// 定义接口
type Programmer interface {
Say() string
}
// 定义类
type GoProgrammer struct {
}
// 定义方法，方法定义和接口相同就是实现了这个接口
func (g *GoProgrammer) Say() string {
return "hello"
}
func main() {
// 定义接口变量
var p Programmer
// 实现接口
w = new(GoProgrammer)
// 调用接口方法
w.Say()
}
11.重写
type Pet struct {
}
type Dog struct {
Pet
}
func (p *Pet) Say() {
fmt.Println("pet is saying")
}
func (p *Pet) Eat() {
fmt.Println("pet is eating")
}
func (d *Dog) Say() {
fmt.Println("dog is saying")
}
func TestExtension(t *testing.T) {
dog := new(Dog)
dog.Eat() //pet is eating
dog.Say() // dog is saying
}
12.错误机制
errors.New("test")
func TestRecover(t *testing.T) {
defer func() {
if err := recover() ; err != nil {
fmt.Println(err)
}
fmt.Print("over")
}()
panic(errors.New("problem"))
}
13.协程
// 如果main协程退出，那么所有协程都会退出
func TestMyGo(t *testing.T) {
for i:=0 ; i < 10 ; i++ {
go func(i int) {
fmt.Println(i)
}(i)
time.Sleep(100 * time.Microsecond)
}
}
// 使用锁机制避免资源竞争
var mut sync.Mutex
counts := 0;
for i:=0 ; i < 5000 ; i++ {
go func() {
defer func() {
mut.Unlock() //解锁
}()
mut.Lock() // 锁住
counts++
}()
}
time.Sleep(time.Second)
println(counts)
}
14.通道
- 通道是协程通信使用的媒介
- 不带缓冲区的通道会有阻塞作用
// 创建一个 channel (带缓冲区和不带缓冲区的）
ch1 := make(chan string)
ch2 := make(chan string, 2)
// 往通道里面写东西
go func() {
ch1 <- "go"
ch2 <- "php"
}()
// 读通道
println(<-ch1)
for ret := range ch2
// 关闭channel
close(ch1)
close(ch2)
15.多路选择
// 多渠道的选择
select {
case ret := <-retCh1:
t.Log(ret)
case ret := <-retCh2:
t.Log(ret)
default:
t.Error("No one returned")
}
// 超时控制
select {
case ret := <-retCh:
t.Log(ret)
case <-time.After(time.Second):
t.Log("time out")
}
16.使用通道进行异步消费
func TestChannelClose(t *testing.T) {
ch := make(chan int)
var wg sync.WaitGroup
wg.Add(1)
dataProducer(ch, &wg)
wg.Add(1)
dataReceiver(ch, &wg)
wg.Wait()
}
// 生产者
func dataProducer(ch chan int , wg *sync.WaitGroup) {
go func() {
for i:=0; i < 20; i++ {
ch <-i
}
close(ch) // 如果不关闭通道，获取的时候一直返回了的是 零值, true 。只有关闭的时候才会返回 nil, false
wg.Done()
}()
}
// 消费者
func dataReceiver(ch chan int , wg *sync.WaitGroup) {
go func() {
for{
if data, ok := <-ch; ok {
fmt.Println(data)
}else {
break
}
}
wg.Done()
}()
}
17.关闭通道
- 关闭一个未初始化(nil) 的 channel 会产生 panic
- 重复关闭同一个 channel 会产生 panic
向一个已关闭的 channel 中发送消息会产生 panic - 从已关闭的 channel 读取消息不会产生 panic，且能读出 channel 中还未被读取的消息，若消息均已读出，则会读到类型的零值。
- 从一个已关闭的 channel 中读取消息永远不会阻塞，并且会返回一个为 false 的 ok-idiom，可以用它来判断 channel 是否关闭
- 关闭 channel 会产生一个广播机制，所有向 channel 读取消息的 goroutine 都会收到消息
func TestCloseChannel(t *testing.T) {
ch := make(chan int)
for i:=0 ; i < 5 ; i++ {
// 创建五个协程
go func(i int, ch chan int) {
for {
if isCancel(ch) {
// 能消费到就会退出
break
}
time.Sleep(time.Microsecond * 5)
}
fmt.Println(i, "cancel")
}(i, ch)
}
cancle1(ch)
time.Sleep(time.Second)
}
func cancle1(ch chan int) {
// 关闭有通道广播的作用，所有消费者都能收到通知，即 <-ch, 拿到对应的类型的零值
close(ch)
}
func cancle2(ch chan int) {
// 只塞了一个值，那么只会有一个消费者拿到数据
ch <- 1
}
func isCancel(ch chan int) bool{
select {
case ret := <-ch:
fmt.Println(ret)
return true
default:
return false
}
}
18.Context
- 根 Context : 通过 context.Background() 创建
- 子 Context：context.WithCancel(parentContext) 创建, ctx, cancel := context.WithCancel(context.Background())
- 当前 Context 被取消时，基于他的子 context 都会被取消
- 接收取消通知 <-ctx.Done()
func TestMyContext(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background()) // 返回上下文和取消上下文的方法
for i:=0 ; i < 5; i++ {
go func(i int, ctx context.Context) {
for {
if isCancelled(ctx) {
break
}
time.Sleep(time.Microsecond * 5)
}
fmt.Println(i, "Cancelled")
}(i, ctx)
}
cancel() // 关闭上下文
time.Sleep(time.Second)
}
func isCancelled(ctx context.Context) bool {
select {
case <-ctx.Done(): // 上下文结束
return true
default:
return false
}
}
19.sync once 使用
func TestSyncOnce(t *testing.T) {
for i:=0; i<3; i++ {
go doOnce() //只会有一个协程执行成功
}
}
func doOnce() {
once.Do(func() {
println("我只能执行一次")
})
}
20.sync pool 使用
- 尝试从私有对象获取（只有一个）
- 私有对象不存在，尝试从当前的 processor的共享池获取（会有锁的开销）
- 如果当前processor共享池也是空的，那么就尝试去其他 processor的共享池获取
- 如果所有子池都是空的，最后就用用户指定的 new 函数产生一个新的对象返回
- GC会清除 sync.pool 缓存的对象
- 对象的缓存有效期为下一次GC之前
- 适合通过复用，降低复杂对象的创建和GC代价
- 协程安全，会有锁的开销
- 生命周期受 GC 影响，不适合于做连接池等，需自己管理生命周期的资源的池化
func TestSyncPoolTest(t *testing.T) {
pool := &sync.Pool{
New: func() interface{
}{
return 0
}}
v := pool.Get().(int)
fmt.Println(v)// 0 默认调用自定义的 new 方法
pool.Put(3) // 优先放在私有变量中
w := pool.Get().(int) // 拿池里面的东西
fmt.Println(w) //3
}
21.反射
- reflect.TypeOf 返回类型（reflect.Type)
- reflect.ValueOF 返回值（reflect.Value)
- 可以从 reflect.Value 获得类型
- 通过 kind 来判断类型
func TestReflect(t *testing.T) {
var s int32
fmt.Println(getType(s))// int
}
func getType(v interface{
}) string {
t := reflect.TypeOf(v) // 返回值是 reflect.Type
switch t.Kind() {
// 获得类型
case reflect.Int32, reflect.Int64:
return "int"
case reflect.Float32, reflect.Float64:
return "float"
default:
return "Unknown"
}
}
22.内置 json 解析
type Man struct {
Name string `json:"name"`
Age int64 `json:"age"`
Sons [2]Son
}
type Son struct {
SonName string `json:"son_name"`
SonAge int64 `json:"son_age"`
}
func main() {
man := Man{
}
man.Age = 32
man.Name = "china"
son := Son{
}
son.SonName = "son"
son.SonAge = 2
man.Sons[0] = son
rs, _ := json.Marshal(man)
fmt.Println(string(rs)) // {"name":"china","age":32,"address":"xxx","Sons":[{"son_name":"son","son_age":2},{"son_name":"","son_age":0}]}
}
23.构建HTTP服务
func TestMyHttp(t *testing.T) {
http.HandleFunc("/", sayHelloName) // 路由
err := http.ListenAndServe(":9000", nil) // 监听服务
if err != nil {
log.Fatal("err", err)
}
}
func sayHelloName(w http.ResponseWriter, r *http.Request) {
_ = r.ParseForm() //先解析才可以获取格式化好的参数, 否则下面打印出来是空map
fmt.Println(r.Form)
}