您好!
欢迎来到京东云开发者社区
登录
首页
博文
课程
大赛
工具
用户中心
开源
首页
博文
课程
大赛
工具
开源
更多
用户中心
开发者社区
>
博文
>
20个Golang片段让我不再健忘
分享
打开微信扫码分享
点击前往QQ分享
点击前往微博分享
点击复制链接
20个Golang片段让我不再健忘
18****
2023-06-05
IP归属:北京
7200浏览
# 前言 本文使用代码片段的形式来解释在 `go` 语言开发中经常遇到的小功能点,由于本人主要使用 `java` 开发,因此会与其作比较,希望对大家有所帮助。 ## 1. hello world 新手村的第一课,毋庸置疑。 ```go package main import "fmt" func main() { fmt.Printf("hello world") } ``` ## 2. 隐形初始化 ```go package main import "fmt" func main() { load() } func load() { fmt.Printf("初始化..手动%s 不错\n", "1") } func init() { fmt.Printf("隐形初始化。。\n") } ``` 在 go 中定义 `init` 函数,程序在运行时会自动执行。类似使 `junit` 的 `@before` 注解。 ## 3. 多模块的访问 `java` 中 `package` 包的概念,`go` 是通过文件夹 + `package` 关键字来定义的。 一般而言,我们会通过`go init`来创建项目,生成的`go.mod`文件位于根目录。 常见的实践是,创建文件夹并且保持 package 名称与文件夹保持一致。这样 `import` 的永远是文件夹,遵循以上规则则意味着文件夹的名称即为模块名。 同一个 `package` 可以创建多个 `.go` 文件,虽然分布在不同的文件中。但是他们中的方法名称不能相同。需要注意,这里与 `java`中不同类中方法可以重名不同。 此外,也没有诸如`private、protected、public`等包访问权限关键字。只要定义的函数首字母为大写。则可以被外部成功调用。 来看一下示例: ```go go-tour └── ch3 ├── model │ └── test │ │ ├── testNest.go │ └── helper.go │ └── helper2.go │ └── main.go └── go.mod ``` 此处,`ch3、model、test` 均为文件夹,也可以说是 `package`。`helper.go` 位于 `model` 下,它的代码如下: ```go package model import "fmt" var AppName = "bot" var appVersion = "1.0.0" func Say() { fmt.Printf("%s", "hello") } func init() { fmt.Printf("%s,%s", AppName, appVersion) } ``` 再来看看 `main.go` ```go package main import ( "ch3/model" "ch3/model/test" ) func main() { model.Say() } ``` 显然它的调用是通过 `packageName.MethodName()` 来使用的。需要注意的是,一个 `go.mod` 下只能有一个 `main` 包。 ## 4. 引用外部库 和 `java` 的 `maven` 类似,`go` 几经波折也提供了官方仓库。如下,通过 `go get github.com/satori/go.uuid` 命令即可安装 `uuid` 库,未指定版本,因此下载的为最新版本。 使用时是这样的: ```go package main import ( "fmt" uuid "github.com/satori/go.uuid" ) func main() { uuid := uuid.NewV4() fmt.Printf("%s", uuid) } ``` ## 5. 数组字典和循环 直接看代码就是了。 ```go package main import "fmt" var item []int var m = map[int]int{ 100: 1000, } var m2 = make(map[int]int) func main() { for i := 0; i < 10; i++ { item = append(item, i) m[i] = i m2[i] = i } for i := range item { fmt.Printf("item vlaue=%d\n", i) } for key, value := range m { fmt.Printf("m:key=%d,value=%d\n", key, value) } for _, value := range m2 { fmt.Printf("m2:value=%d\n", value) } } ``` - := 的形式只能在方法内 - 全局的只能用 var x=.. - map输出没有顺序 ## 6. 结构体和JSON `go` 中通过 `struct` 来定义结构体,你可以把它简单理解为对象。一般长这样。 ```go type App struct { AppName string AppVersion string `json:"app_version"` appAuthor string "pleuvoir" DefaultD string "default" } ``` 我们经常在 `java` 程序中使用 `fastjson` 来输出 `JSON字符串`。 `go` 中自带了这样的类库。 ```go package main import ( app2 "app/app" //可以定义别名 "encoding/json" "fmt" ) func main() { a := app2.App{} fmt.Printf("%s\n", a) app := app2.App{AppName: "bot", AppVersion: "1.0.1"} json, _ := json.Marshal(app) //转换为字符串 fmt.Printf("json is %s\n", json) } ``` - 结构体中 `JSON` 序列化不会转变大小写,可以指定它输出的 `key`名称通过 json:xxx 的描述标签。 - 结构体中的默认值赋值了也不展示 ## 7. 异常处理 作为一个有经验的程序员:),`go` 的异常处理涉及的很简单,也往往为人所诟病。比如满屏幕的 `err` 使用。 ```go package main import ( "fmt" "os" ) func _readFile() (int, error) { file, err := os.ReadFile("test.txt") if err != nil { fmt.Printf("error is = %s\n", err) return 0, err } fmt.Printf("file = %s \n", file) return len(file), err } func readFile() (int, error) { fileLength, err := _readFile() if err != nil { fmt.Printf("异常,存在错误 %s\n", err) } return fileLength, err } func main() { fileLength, _ := readFile() fmt.Printf("%d\n", fileLength) } ``` 和 `java` 不同,它支持多返回值,为我们的使用带来了很多便利。如果不需要处理这个异常,可以使用 `_` 忽略。 ## 8. 异步 千呼万唤始出来,令人兴奋的异步。 ```go package main import ( "bufio" "fmt" "os" ) func worker() { for i := 0; i < 10; i++ { fmt.Printf("i=%d\n", i) } } func main() { go worker() go worker() //阻塞 获取控制台的输出 reader := bufio.NewReader(os.Stdin) read, err := reader.ReadBytes('\n') //注意是单引号 回车后结束控制台输出 if err != nil { fmt.Printf("err is =%s\n", err) return } fmt.Printf("read is %s \n", read) } ``` 如此的优雅,如此的简单。只需要一个关键字 `go` 便可以启动一个协程。我们在 `java` 中经常使用的是线程池,而在 `go` 中也存在协程池。据我观察,部分协程池 `benchmark` 的性能确实比官方语言关键字高很多。 ## 9. 异步等待 这里就类似 `java` 中使用 `countdownLatch` 等关键字空值并发编程中程序的等待问题。 ```go package main import ( "fmt" "sync" "time" ) func upload(waitGroup *sync.WaitGroup) { for i := 0; i < 5; i++ { fmt.Printf("正在上传 i=%d \n", i) } time.Sleep(5 * time.Second) waitGroup.Done() } func saveToDb() { fmt.Printf("保存到数据库中\n") time.Sleep(3 * time.Second) } func main() { begin := time.Now() fmt.Printf("程序开始 %s \n", begin.Format(time.RFC850)) waitGroup := sync.WaitGroup{} waitGroup.Add(1) go upload(&waitGroup) go saveToDb() waitGroup.Wait() fmt.Printf("程序结束 耗时 %d ms ", time.Now().UnixMilli()-begin.UnixMilli()) } ``` `sync` 包类似于 `J.U.C` 包,里面可以找到很多并发编程的工具类。`sync.WaitGroup` 便可以简简单单认为是 `countdownLatch` 吧。也不能多次调用变为负数,否则会报错。 注意,这里需要传入指针,因为它不是一个引用类型。一定要通过指针传值,不然进程会进入死锁状态。 ## 10. 管道 ```go package main import ( "fmt" "sync" ) var ch = make(chan int) var sum = 0 //是线程安全的 func consumer(wg *sync.WaitGroup) { for { select { case num, ok := <-ch: if !ok { wg.Done() return } sum = sum + num } } } func producer() { for i := 0; i < 10_0000; i++ { ch <- i } close(ch) //如果不关闭则会死锁 } func main() { wg := sync.WaitGroup{} wg.Add(1) go producer() go consumer(&wg) wg.Wait() fmt.Printf("sum = %d \n", sum) } ``` 这里演示的是什么呢?管道类似一个队列,进行线程间数据的传递。当关闭时消费端也退出,如果没关闭管道,运行时会报死锁。可以看出全局变量在线程间是安全的。 可以衍生出一种固定写法: ```go //固定写法 func consumer(wg *sync.WaitGroup) { for { select { case num, ok := <-ch: if !ok { wg.Done() return } sum = sum + num } } } ``` ## 11. 接口 ```go package main import "fmt" type Person interface { Say() SetName(name string) } type ZhangSan struct { Value string } func (z *ZhangSan) Say() { fmt.Printf("name=%s", z.Value) } func (z *ZhangSan) SetName(name string) { z.Value = name + ":hehe" } func main() { zhangSan := ZhangSan{} zhangSan.SetName("pleuvoir") zhangSan.Say() } ``` 如上的程序演示了接口的使用。 - go的接口没有强依赖 - 通过结构体 + 方法的形式实现,注意方法传入的可以是引用也可以是值 ## 12. 锁 ```go package main import ( "fmt" "sync" ) type Number struct { Value int mutex sync.Mutex //加锁 } func (receiver *Number) Add() { receiver.mutex.Lock() defer receiver.mutex.Unlock() //退出时会执行 receiver.Value = receiver.Value + 1 //fmt.Printf("add\n") } func (receiver *Number) Get() int { receiver.mutex.Lock() defer receiver.mutex.Unlock() return receiver.Value } func main() { number := Number{Value: 0} wg := sync.WaitGroup{} n := 100_0000 wg.Add(n) for i := 0; i < n; i++ { go func(wg *sync.WaitGroup) { number.Add() wg.Done() }(&wg) } wg.Wait() fmt.Printf("count=%d", number.Get()) } ``` 这里是什么?显然就像是显示锁的 `ReentrantLock` 的使用,相信大家都能看懂。这里出现了新关键字 `defer`,我暂且是理解为 `finally`。不知道你怎么看? ## 13. 读写配置文件 这也是一个很常规的功能,看看怎么实现。 ```go package main import ( "encoding/json" "fmt" "os" ) type Preferences struct { Name string `json:"name"` Version float64 `json:"version"` } const configPath = "config.json" func main() { preferences := Preferences{Name: "app", Version: 100.01} marshal, err := json.Marshal(preferences) err = os.WriteFile(configPath, marshal, 777) if err != nil { fmt.Printf("写入配置文件错误,%s\n", err) return } //读取配置文件 file, err := os.ReadFile(configPath) if err != nil { fmt.Printf("读取文件错误,%s\n", err) return } fmt.Printf("%s\n", file) //{"name":"app","version":100.01} //构建一个对象用来序列化 readConfig := Preferences{} //反序列化 err = json.Unmarshal(file, &readConfig) if err != nil { fmt.Printf("配置文件转换为JSON错误,%s\n", err) } fmt.Printf("%v", readConfig) //{app 100.01} ``` 这里挺没意思的,写入 `JSON` 字符串,然后读取回来在加载到内存中。不过,简单的示例也够说明问题了。 ## 14. 宕机处理 这是类似于一种最上层异常捕获的机制,在程序的入口处捕获所有的异常。 ```go package main import ( "fmt" "time" ) func worker() { //defer func() { //不能写在主函数,最外层catch没啥用 // if err := recover(); err != nil { // fmt.Printf("%s", err) // } //}() defer recovery() panic("严重错误") } func recovery() { if err := recover(); err != nil { fmt.Printf("死机了。%s\n", err) } } func main() { for true { worker() time.Sleep(1 * time.Second) } } ``` 注释写的很清楚,聪明的你一看就懂。 ## 15. 单元测试 与 `java` 不同,`go` 建议单元测试文件尽可能的离源代码文件近一些。比如这样: ``` go-tour └── main.go └── main_test.go ``` 并且它的命名也是这样简单粗暴: ```go package main import ( "testing" ) func TestInit(t *testing.T) { t.Log("heh") helper := PersonHelper{} helper.init("pleuvoir") t.Log(helper.Name) } ``` 以大写的 `Test` 开头,文件名称以 `_test` 结尾,很清爽的感觉。 ## 16. 启动传参 这也是一个很常用的知识点。这里有两种方式: - 直接传 - 使用 flag ```go package main import ( "encoding/json" "flag" "fmt" "os" ) func main() { //第一种方式 args := os.Args for i, arg := range args { println(i, arg) } //第二种方式 config := struct { Debug bool Port int }{} flag.BoolVar(&config.Debug, "debug", true, "是否开启debug模式") flag.IntVar(&config.Port, "port", 80, "端口") flag.Parse() json, _ := json.Marshal(config) fmt.Printf("json is %s\n", json) } ``` 我建议使用第二种,更便捷自带类型转换,还可以给默认值,非常好。 ## 17. 优雅退出 ```go package main import ( "fmt" "os" "os/signal" "syscall" ) func quit() { println("执行一些清理工作。。") } //正常的退出 //终端 CTRL+C退出 //异常退出 func main() { defer quit() println("进来了") //读取信号,没有一直会阻塞住 exitChan := make(chan os.Signal) //监听信号 signals := make(chan os.Signal) signal.Notify(signals, syscall.SIGINT, syscall.SIGQUIT) go func() { //有可能一次接收到多个 for s := range signals { switch s { case syscall.SIGINT, syscall.SIGQUIT: println("\n监听到操作系统信号。。") quit() //如果监听到这个信号没处理,那么程序就不会退出了 if i, ok := s.(syscall.Signal); ok { value := int(i) fmt.Printf("是信号类型,准备退出 %d", value) } else { println("不知道是啥,0退出") os.Exit(0) } // os.Exit(value) exitChan <- s } } }() println("\n程序在这里被阻塞了。") <-exitChan //panic("heh") println("\n阻塞被终止了。") } ``` 这其实是在监听操作系统的信号,`java` 中也有类似的回调的接口(我忘了名字)。 ## 18. 反射 作为一门高级语言,反射肯定是有的。还是使用 `reflect` 包。 ```go package main import ( "fmt" "reflect" ) type Person struct { Name string `json:"name"` } func (p *Person) SetName(name string) { p.Name = name } func (p *Person) GetName() (string, string) { return p.Name, "1.0.1" } func worker1() { p := Person{} p.SetName("pleuvoir") name, _ := p.GetName() fmt.Printf(name) } // 获取方法 func worker2() { p := Person{} rv := reflect.ValueOf(&p) value := []reflect.Value{reflect.ValueOf("peluvoir")} rv.MethodByName("SetName").Call(value) values := rv.MethodByName("GetName").Call(nil) for i, v := range values { fmt.Printf("\ni=%d,value=%s\n", i, v) } } func worker3() { s := Person{} rt := reflect.TypeOf(s) if field, ok := rt.FieldByName("Name"); ok { tag := field.Tag.Get("json") fmt.Printf("tag is %s \n", tag) } } func main() { //正常获取 worker1() //获取方法 worker2() //获取标签 worker3() } ``` 没什么好说的,写代码全靠猜。 ## 19. atomic 类似 `java` 中的 `atomic` 原子变量。 ```go package main import ( "fmt" "sync" "sync/atomic" ) func main() { workers := 1000 wg := sync.WaitGroup{} wg.Add(workers) for i := 0; i < workers; i++ { go worker2(&wg) } wg.Wait() fmt.Printf("count = %d", count) } var count int64 = 0 func worker1(wg *sync.WaitGroup) { count++ wg.Done() } func worker2(wg *sync.WaitGroup) { atomic.AddInt64(&count, 1) //特别简单 wg.Done() } ``` 真的是特别简单。 ## 20. 线程安全的Map 类似于`ConcurrentHashMap`,与普通的 `api` 有所不同。 ```go var sessions = sync.Map{} sessions.Store(uuid, uuid) load, ok := sessions.Load(value.Token) if ok { // 做你想做的事情 } ``` ## 21. return func 这里就是函数式变成的例子了。函数是一等公民可以作为参数随意传递。`java` 什么时候能支持呢? ```go package main import "fmt" func main() { engine := Engine{} engine.Function = regular() function := engine.Function for i := 0; i < 3; i++ { s := function("pleuvoir") fmt.Printf("s is %s\n", s) } } type Engine struct { Function func(name string) string } func regular() (ret func(name string) string) { fmt.Printf("初始化一些东西。\n") return func(name string) string { fmt.Printf("我是worker。name is %s\n", name) return "我是匿名函数的返回值" } } ``` 比如这里,如果要初始化日志什么。最后需要让框架在哪里打印日志,就需要将这个初始化的日志实例传递过去。总而言之,言而总之。会需要让代码各种传递。 这种方式在于第一次调用的时候会执行上面的代码片段,后面只是保存了这个函数的句柄,然后可以一直调用这个匿名函数。 ## 22. context ```go package main import ( "context" "fmt" "time" ) func main() { worker1() } func worker1() { //总共2秒超时 value := context.WithValue(context.Background(), "token", "pleuvoir") timeout, cancelFunc := context.WithTimeout(value, 5*time.Second) defer cancelFunc() //模拟任务 fmt.Println("开始任务") deep := 10 go handler(timeout, deep) fmt.Println("开始阻塞", time.Now()) //等待主线程超时,阻塞操作 select { case <-timeout.Done(): fmt.Println("阻塞结束", timeout.Err(), time.Now()) } } // 模拟任务处理,循环下载图片等 func handler(timeout context.Context, deep int) { if deep > 0 { fmt.Printf("[begin]token is %s %s deep=%d\n", timeout.Value("token"), time.Now(), deep) time.Sleep(1 * time.Second) go handler(timeout, deep-1) } //下面的哪个先返回 先执行哪个 //如果整体超时 或者 当前方法超过2秒 就结束 select { //等待超时会返回 case <-timeout.Done(): fmt.Println("超时了。", timeout.Err()) //等待这么久 然后会返回 这个函数可不是比较时间,这里其实是在模拟处理任务,固定执行一秒 和休息一秒效果一样 //但是休息一秒的话就不会实时返回了,所以这里实际应用可以是一个带超时的回调? case <-time.After(time.Second): fmt.Printf("[ end ]执行完成耗时一秒 %s %d\n", time.Now(), deep) } } ``` 作用:在不同的协程中传递上下文。 - 传值 类似于threadLocal - 可以使用超时机制,无论往下传递了多少协程,只要最上层时间到了 后面的都不执行 - 俄罗斯套娃一次一层包装 ## 23. 字符串处理 这是最高频率的操作了,使用任何语言都无法错过。 ```go package main import ( "fmt" "strings" ) func main() { str := " pleuvoir " trimSpace := strings.TrimSpace(str) fmt.Printf("去除空格 %s\n", trimSpace) subString := trimSpace[4:len(trimSpace)] fmt.Printf("subString after is %s\n", subString) prefix := strings.HasPrefix(subString, "vo") fmt.Printf("是否有前缀 vo : %v\n", prefix) suffix := strings.HasSuffix(subString, "ir") fmt.Printf("是否有后缀 ir : %v\n", suffix) builder := strings.Builder{} builder.WriteString("hello") builder.WriteString(" ") builder.WriteString("world") fmt.Printf("stringBuilder append is %s\n", builder.String()) eles := []string{"1", "2"} join := strings.Join(eles, "@") fmt.Printf("join after is %s\n", join) //拼接格式化字符串,并且能返回 sprintf := fmt.Sprintf("%s@%s", "1", "20") fmt.Printf("Sprintf after is %s\n", sprintf) //打印一个对象 比较清晰的方式 person := struct { Name string Age int }{"pleuvoir", 18} fmt.Printf("%v", person) // 输出 {Name:pleuvoir Age:18} } ``` 主要是使用 `fmt` 包。 ## 24. 任务投递 如果说使用 `go` 最激动人心的是什么?是大量的协程。如果在下载任务中,我们可以启动很多协程进行分片下载。如下,即展示使用多路复用高速下载。 ```go package main import ( "fmt" "sync" "time" ) func main() { chunks := 10 //文件分成n份 workers := 5 //个线程处理 wg := sync.WaitGroup{} wg.Add(chunks) jobs := make(chan int, chunks) //带缓冲的管道 等于任务数 for i := 0; i < workers; i++ { go handler1(i, jobs, &wg) } //将任务全部投递给worker scheduler(jobs, chunks) wg.Wait() fmt.Println("download finished .") } // 分成 chunks 份任务 里分发 // 将 n 份下载任务都到管道中去,这里管道数量等于 任务数量n 管道不会阻塞 func scheduler(jobs chan int, chunks int) { for i := 0; i < chunks; i++ { //time.Sleep(time.Duration(rand.Intn(3)) * time.Second) jobs <- i } } // 写法2 // 注意这里的是直接接受管道,这也是一种固定写法,下面的 range jobs 可以认为是阻塞去抢这个任务,多个线程都在抢任务 func handler2(workerId int, jobs <-chan int, wg *sync.WaitGroup) { for job := range jobs { // fmt.Printf("workerId[%d] job[%d] start download .\n", workerId, job) time.Sleep(1 * time.Second) fmt.Printf("workerId[%d] job[%d] download ok.\n", workerId, job) wg.Done() //这里不要break,这样执行完当前的线程就能继续抢了 } } // 写法1,select case 多路复用 func handler1(workerId int, jobs chan int, wg *sync.WaitGroup) { for { select { case job, _ := <-jobs: // fmt.Printf("workerId[%d] job[%d] start download .\n", workerId, job) time.Sleep(3 * time.Second) fmt.Printf("workerId[%d] job[%d] download ok.\n", workerId, job) wg.Done() //这里不要break,这样执行完当前的线程就能继续抢了 } } } ``` # 后语 以上都是一个新手 `Gopher` 的经验总结,文中难免有错误,恳请指正。
上一篇:【618备战巡礼】“三高”之第一高--如何打造高可用系统
下一篇:轻量灵动: 革新轻量级服务开发
18****
文章数
1
阅读量
180
作者其他文章
01
20个Golang片段让我不再健忘
前言本文使用代码片段的形式来解释在 go 语言开发中经常遇到的小功能点,由于本人主要使用 java 开发,因此会与其作比较,希望对大家有所帮助。1. hello world新手村的第一课,毋庸置疑。package mainimport "fmt"func main() { fmt.Printf("hello world")}2. 隐形初始化package mainimport "fmt"func
18****
文章数
1
阅读量
180
作者其他文章
添加企业微信
获取1V1专业服务
扫码关注
京东云开发者公众号