版权声明：诸葛老刘所有 https://blog.csdn.net/weixin_39791387/article/details/86497801
本文适合对GO的基本语法有所了解的人阅读
- 切片(slice)的使用
package main
import (
"fmt"
)
func main() {
x := make([]int, 0, 5) // 创建容量为5个元素的切片
for i := 0; i < 10 ; i++ {
x = append(x, i) // 追加数据, 当超出容量限制时, 自动分配更大的存储空间
}
fmt.Println(x)
}
输出结果:
[0 1 2 3 4 5 6 7 8 9]
- 字典(map)类型, 将其内置, 可直接从运行时层面获得性能优化
package main
import (
"fmt"
)
func main() {
m := make(map[string]int) //创建字典类型的对象
m["x"] = 1 // 添加或设置key/value, 类似python的字典操作方法
x, ok := m["b"] // 使用ok-idiom获取值, 可用来判断key/value是否存在
fmt.Println(x, ok)
delete (m, "x") // 删除
}
输出结果:
0 false
所谓
ok-idion模式, 是指在多返回值中用一个名为ok的布尔值来标示操作是否成功. 因为很多操作默认返回零值, 所以在此额外说明下
- 结构体(struct)的使用, 可匿名嵌入其它类型
package main
import (
"fmt"
)
type user struct { // 定义一个user的结构体类型, 类似python 的类
name string
age int
}
type manager struct {
user // 匿名嵌入其它类型, 类似python 类的继承
title string
}
func main() {
var m manager
m.name = "Tom" // 直接访问匿名字段的成员 类似乎python 类继承后的属性访问
m.age = 20
m.title = "CTO"
fmt.Println(m)
}
输出结果:
{{Tom 20} CTO}
- 方法的使用
- 可以为当前包内的任意类型定义方法
package main
import (
"fmt"
)
type X int
func (x *X) inc() { // 名称前的参数称作 receiver, 作用类似 python 类的self
*x++
}
func main() {
var x X
x.inc()
fmt.Println(x)
}
输出结果:
1
还可以使用匿名字段的方法, 这种方式可实现与继承类似的功能.
package main
import (
"fmt"
)
type user struct {
name string
age int
}
func (u user) ToString() string{
return fmt.Sprintf("%+v", u)
}
type manager struct {
user
title string
}
func main() {
var m manager
m.name = "Tom"
m.age = 40
fmt.Println(m.ToString())
}
输出结果:
{name:Tom age:40}
- 接口类型的简单使用
接口采用了duck type方式, 也就是说无须在实现类型上添加显式声明
package main
import (
"fmt"
)
type user struct {
name string
age int
}
func (u user) Print() {
fmt.Printf("%+v\n", u)
}
type Printer interface { //接口类型
Print()
}
func main() {
var u user
u.name = "TOM"
u.age = 20
var p Printer = u // 只要包含接口所需要的全部方法, 即表示实现了该接口
p.Print()
}
输出结果:
{name:TOM age:20}
- 并发
GO的整个运行时完全并发化设计. 凡你能看到的,几乎都是以
goroutine(可以理解为:go + routine)的方式运行. 这是一种比普通协程或线程更加高效的并发设计,能轻松创建和运行成千上万的并发任务.
package main
import (
"fmt"
"time"
)
func task(id int) {
for i := 0; i < 5; i++ {
fmt.Printf("%d: %d \n",id, i)
time.Sleep(time.Second)
}
}
func main() {
go task(1) // 创建goroutine
go task(2)
time.Sleep(time.Second * 6)
}
输出结果:
1: 0
2: 0
1: 1
2: 1
1: 2
2: 2
1: 3
2: 3
1: 4
2: 4
- 通道(channel) 与goroutine 搭配, 实现用通信代替内存共享的CSP模型
package main
// 消费者
func consumer(data chan int, done chan bool) {
for x := range data{ // 接收数据, 直接通道关闭
println("recv:", x)
}
done <- true // 通知 main 消费结束
}
// 生产者
func producer(data chan int) {
for i := 0; i < 4; i++ {
data <- i // 发送数据
}
close(data) // 生产结束, 关闭通道
}
func main(){
done := make(chan bool) // 用于接收消费结束的信息
data := make(chan int) // 数据管道
go consumer(data, done) // 启动消费者
go producer(data) // 启动生产者
<- done // 阻塞, 直到消费者发回结束信号
}
输出结果:
recv: 0
recv: 1
recv: 2
recv: 3