Golang的基本使用

目录

变量的声明

Golang常用容器

defer

有趣的多态

结构体标签和reflect 反射

Golang最强的协程

channel

go可能造成的内存泄露

变量的声明

方法 1:有类型,有var,不赋值 在Golang中默认值为0

方法 2:无类型,有var,赋值

方法 3:无类型,无var,赋值

多变量声明

多变量声明,无类型无var

如下

package main

import (
	"fmt"
)

func main() {
	//var 用于声明变量
	var a int // 方法 1:有类型,有var,不赋值 在Golang中默认值为0
	fmt.Println("a=", a)

	var b = 0 //方法 2:无类型,有var,赋值
	fmt.Println("b=", b)

	c := 0 //方法 3:无类型,无var,赋值
	fmt.Println("c=", c)

	//多变量声明
	var d, e int = 1, 2 //
	fmt.Println("d=", d, "e=", e)

	//多变量声明,无类型无var
	f, g := "string", 3
	fmt.Println("f=", f, "e=", g)

}

常量 

定义后无法改变

Golang常用容器

静态数组(slice)

package main

import "fmt"

func main() {

	//数组,静态数组
	var arr [5]int
	arr[0] = 1
	arr[1] = 2
	arr[2] = 3
	arr[3] = 4
	arr[4] = 5
	fmt.Println(arr)      // 输出: [1 2 3 4 5]
	fmt.Println(len(arr)) // 输出: 5

}

动态数组(array)

跟静态数组的区别,就是 不用规定数组大小,自动分配自动扩容

package main

import "fmt"

func main() {
	//跟静态数组的区别,就是 不用规定数组大小,自动分配自动扩容
	slice := []int{1, 2, 3, 4, 5}
	fmt.Println(slice)      // 输出: [1 2 3 4 5]
	fmt.Println(len(slice)) // 输出: 5
}

自动扩容演示

slice两倍扩容

package main

import "fmt"

func main() {
	//跟静态数组的区别,就是 不用规定数组大小,自动分配自动扩容
	slice := []int{1, 2, 3, 4, 5}
	fmt.Println(slice)      // 输出: [1 2 3 4 5]
	fmt.Println(len(slice)) // 输出: 5
	fmt.Println(cap(slice)) //当前容量为5

	slice = append(slice, 6)
	fmt.Println(len(slice)) // 输出: 数据数量=6
	fmt.Println(cap(slice)) // 输出: 10 slice两倍扩容
}

字符串(string)

package main

import "fmt"

func main() {
	str := "Hello, World!"
	fmt.Println(str)         // 输出: Hello, World!
	fmt.Println(len(str))    // 输出: 13
	fmt.Printf("%s", str[0]) // 输出: H 
}

映射(map)

package main

import "fmt"

func main() {
	m := make(map[int]string)
	m[1] = "apple"
	m[2] = "banana"
	m[3] = "orange"
	for i := 1; i < 4; i++ {
		fmt.Printf("m=%s\n", m[i])
	}
}

defer

类似c++中的析构函数

defer作用：

        释放占用的资源

        捕捉处理异常

        输出日志

func main() {
	defer func() {
		fmt.Println("析构函数")
	}()
	fmt.Println("main start")
	//===
	//业务
	//===
	fmt.Println("main off")
}

当然Golang中有资源自动回收,不用自己析构,当然有特殊的例子下面讲了协程再说

有趣的多态

import "fmt"

// 两个类
type Student struct {
	age int
}

type Programmer struct {
	age int
}

// 同一调用
func whatJob(p Person) {
	p.job()
}

func growUp(p Person) {
	p.growUp()
}

// 一个万能接口
type Person interface { //intetface 万能变量
	job()
	growUp()
}

// Student 函数方法
func (p Student) job() {
	fmt.Println("I am a student.")
	return
}

func (p *Student) growUp() {
	p.age += 1
	return
}

// Programmer 函数方法
func (p Programmer) job() {
	fmt.Println("I am a programmer.")
	return
}

func (p *Programmer) growUp() {
	p.age += 10
	return
}

func main() {
	qcrao := Student{age: 18}
	whatJob(&qcrao)

	growUp(&qcrao)
	fmt.Println(qcrao)

	stefno := Programmer{age: 100}
	whatJob(&stefno)

	growUp(&stefno) //同一个函数,调用结果不同
	fmt.Println(stefno)
}

结构体标签和reflect 反射

import (
	"fmt"
	"reflect"
)

type resume struct {
	Name string `json:"电影" doc:"喜剧之王"`
}

func findDoc(stru interface{}) map[string]string {
	t := reflect.TypeOf(stru).Elem() //reflect 反射 逆推类型
	doc := make(map[string]string)

	for i := 0; i < t.NumField(); i++ {
		doc[t.Field(i).Tag.Get("json")] = t.Field(i).Tag.Get("doc")
	}

	return doc

}

func main() {
	var stru resume
	doc := findDoc(&stru)
	fmt.Printf("电影字段=%s\n", doc["电影"])
}

Golang最强的协程

package main

import (
	"fmt"
	"time"
)

func main() {
	go func() {
		fmt.Println("我是协程")
	}()

	fmt.Println("我是主协程")

	time.Sleep(1 * time.Second) // 等待一秒钟，让协程有足够的时间执行
}

身为一个cpp学者,当看见Golang写协程那么方便,异常兴奋

那么协程用什么与主协程通信呢?

channel

管道(channel)接收和发送数据都是阻塞的

package main

import (
	"fmt"
	"time"
)

func main() {
	c := make(chan int) //创建管道(channel),而且接收和发送数据都是阻塞的
	go func() {
		fmt.Println("我是协程")
		c <- 666 //向管道内写入666
	}()

	a := <-c //管道类读出
	fmt.Println("我是主协程")
	fmt.Println("a=", a)

	time.Sleep(1 * time.Second) // 等待一秒钟，让协程有足够的时间执行
}

go可能造成的内存泄露

func main() {
    ch := func() <-chan int {
        ch := make(chan int)
        go func() {
            for i := 0; ; i++ {
                ch <- i
            }
        } ()
        return ch
    }()

    for v := range ch {
        fmt.Println(v)
        if v == 5 {
            break
        }
    }
}

使用 valgrind 运行 程序,发现 协程内存并没有回收

问题:

上面的程序中后台Goroutine向管道输入自然数序列，main函数中输出序列。

但是当break跳出for循环的时候，后台Goroutine就处于无法被回收的状态了。

因为 Goroutine还在向管道中写数据,主协程已经退出

改正:

使用context

package main

import (
	"context"
	"fmt"
)

func main() {
	//WithCancel(ctx Context, cancel CancelFunc)=(名 Context,处理函数 CancelFunc)
	ctx, cancel := context.WithCancel(context.Background()) //context.Background() 处理 Goroutine

	ch := func(ctx context.Context) <-chan int {
		ch := make(chan int)
		go func() {
			for i := 0; ; i++ {
				select {
				case <-ctx.Done():
					return
				case ch <- i:
				}
			}
		}()
		return ch
	}(ctx)

	for v := range ch {
		fmt.Println(v)
		if v == 5 {
			cancel()
			break
		}
	}
}

当main函数在break跳出循环时，通过调用 context 来通知后台Goroutine退出，

这样就避免了Goroutine的泄漏。