一、条件语句 select
1.1 select 介绍
select {
case communication clause :
statement(s);
case communication clause :
statement(s);
/* 你可以定义任意数量的 case */
default : /* 可选 */
statement(s);
}
select { //不停的在这里检测
case <-chanl : //检测有没有数据可以读
//如果chanl成功读取到数据，则进行该case处理语句
case chan2 <- 1 : //检测有没有可以写
//如果成功向chan2写入数据，则进行该case处理语句
//假如没有default，那么在以上两个条件都不成立的情况下，就会在此阻塞//一般default会不写在里面，select中的default子句总是可运行的，因为会很消耗CPU资源
default:
//如果以上都没有符合条件，那么则进行default处理流程
}
select 语句类似于 switch 语句，但是 select会随机选择一个可运行的 case，如果没有 case可以运行，那么它将一直阻塞直到有 case可用。select 语句中的每个 case 都必须是一个通信操作，要么是发送要么是接收，如果有多个 case 都可以运行，Select 会随机公平地选择出一个执行，其它的不会执行；如果有 default 子句，那么执行该语句；如果没有 default 子句，那么 select 将阻塞，直到某个通信可以运行。
//实例
func main() {
var c1, c2, c3 chan int
var i1, i2 int
select {
case i1 = <-c1:
fmt.Printf("received ", i1, "from c1\n")
case c2 <- i2:
fmt.Printf("sent ", i2, "to c2\n")
case i3, ok := (<-c3):
if ok {
fmt.Printf("received ", i3, "from c3\n")
} else {
fmt.Printf("c3 is closed\n")
}
default:
fmt.Println("no communication\n")
}
}
//output
no communication
1.2 select 典型用法
1.2.1 超时判断
//比如在下面的场景中，使用全局resChan来接受response，如果时间超过3S,resChan中还没有数据返回，则第二条case将执行
var resChan = make(chan int)
// do request
func test() {
select {
case data := <-resChan: //接收到数据
doData(data)
case <-time.After(time.Second * 3): //超时
fmt.Println("request time out")
}
}
func doData(data int) {
//...
}
1.2.2 线程/协程 退出
//主线程（协程）中如下：
var shouldQuit=make(chan struct{})
fun main(){
{
//loop
}
//...out of the loop
select {
case <-c.shouldQuit:
cleanUp()
return
default:
}
//...
}
//再另外一个协程中，如果运行遇到非法操作或不可处理的错误，就向shouldQuit发送数据通知程序停止运行
close(shouldQuit)
1.2.3 判断channel是否阻塞
//在某些情况下是存在不希望channel缓存满了的需求的，可以用如下方法判断
ch := make (chan int, 5)
//...
data：=0
select {
case ch <- data:
default:
//做相应操作，比如丢弃data。视需求而定
}
二、循环语句 range
//例1
func main() {
a := [3]int{0, 1, 2}
for i, v := range a { // index、value 都是从复制品中取出。
if i == 0 { // 在修改前，我们先修改原数组。
a[1], a[2] = 999, 999
fmt.Println(a) // 确认修改有效，输出 [0, 999, 999]。
}
a[i] = v + 100 // 使用复制品中取出的 value 修改原数组。
}
fmt.Println(a) // 输出 [100, 101, 102]。
}
//output
[0 999 999]
[100 101 102]
func main() {
s := []int{1, 2, 3, 4, 5}
for i, v := range s { // 复制 struct slice { pointer, len, cap }。
if i == 0 {
s = s[:3] // 对 slice 的修改,不会影响 range,这里不是对底层数据的修改,所以无影响
s[2] = 100 // 对底层数据的修改。
}
println(i, v)
}
}
//output
0 1
1 2
2 100
3 4
4 5
对数组使用 range-for 会复制一份底层数组，index、value均从复制品中取出；slice 作为引用类型被 range-for 时不会复制底层数据，对于底层数据的修改会影响到 range 循环。
type student struct {
name string
age int
}
func main() {
m := make(map[string]*student)
stus := []student{
{name: "pprof.cn", age: 18},
{name: "测试", age: 23},
{name: "博客", age: 28},
}
for _, stu := range stus {
m[stu.name] = &stu //这里每次取复制对象的地址,都是同一个地址,取得最后循环到的对象的值
}
for k, v := range m {
fmt.Println(k, "=>", v.name)
}
}
//output
pprof.cn => 博客
测试 => 博客
博客 => 博客