Go语法背后的秘密作业题解

背景介绍

环境

  • 操作系统
    • 本机：MacOS 15
    • 远程： 阿里云封装的centos
  • go版本
    • 本机：go1.21.0
    • 远程：go1.14.12
  • IDE：GoLand
  • 辅助：ChatGPT 4o
1
2
3
4
5
6
7
8
9
10
11
$ cat /etc/os-release
NAME="Alibaba Cloud Linux"
VERSION="3 (Soaring Falcon)"
ID="alinux"
ID_LIKE="rhel fedora centos anolis"
VERSION_ID="3"
UPDATE_ID="9.1"
PLATFORM_ID="platform:al8"
PRETTY_NAME="Alibaba Cloud Linux 3 (Soaring Falcon)"
ANSI_COLOR="0;31"
HOME_URL="https://www.aliyun.com/"

环境准备

在本机MacOS15预览版上使用始终有问题，换用自有aliyun服务器，由于阿里云服务器代理不易设置，不好获取给的docker image，于是将本机环境的image打包后scp上去

1
2
3
4
5
6
# 本机
docker save -o go1.14.12-dev.tar xargin/go1.14.12-dev

# 远程
docker load -i go1.14.12-dev.tar
docker docker run -it -v /home/awyd234/study/ch02/:/work xargin/go1.14.12-dev

必做一 channel 一页中，找出所有红线报错在 runtime 中的位置，使用 Go 1.14.12 版本

作业内容

Close nil

代码

1
2
3
4
5
6
7
package main

func main() {
	var ch chan int
	close(ch)
	ch <- 1
}

报错提示

1
2
3
4
5
6
7
❯ go run close_nil.go                                         
panic: close of nil channel

goroutine 1 [running]:
main.main()
        /work/close_nil/close_nil.go:5 +0x2a
exit status 2

dlv分析

先用dlv启动

1
dlv debug close_nil.go

对main打断点 

1
b main.main

运行到close(ch)前

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
(dlv) c
> main.main() ./send_to_nil.go:3 (hits goroutine(1):1 total:1) (PC: 0x46019f)
     1: package main
     2:
=>   3: func main() {
     4:         var ch chan int
     5:         close(ch)
     6:         ch <- 1
     7: }
(dlv) n
> main.main() ./send_to_nil.go:4 (PC: 0x4601ad)
     1: package main
     2:
     3: func main() {
=>   4:         var ch chan int
     5:         close(ch)
     6:         ch <- 1
     7: }
(dlv) n
> main.main() ./send_to_nil.go:5 (PC: 0x4601b6)
     1: package main
     2:
     3: func main() {
     4:         var ch chan int
=>   5:         close(ch)
     6:         ch <- 1
     7: }

连续使用si命令进入

1
2
3
4
5
6
7
8
9
10
11
12
13
> runtime.closechan() /usr/local/go/src/runtime/chan.go:342 (PC: 0x404d4a)
Warning: debugging optimized function
   337:         memmove(dst, src, t.size)
   338: }
   339:
   340: func closechan(c *hchan) {
   341:         if c == nil {
=> 342:                 panic(plainError("close of nil channel"))
   343:         }
   344:
   345:         lock(&c.lock)
   346:         if c.closed != 0 {
   347:                 unlock(&c.lock)

可以看到在runtime/chan.go的342行有相关检查panic

Write close

代码

1
2
3
4
5
6
7
package main

func main() {
	ch := make(chan int)
	close(ch)
	ch <- 1
}

报错提示

1
2
3
4
5
6
7
# go run write_close.go
panic: send on closed channel

goroutine 1 [running]:
main.main()
        /work/write_close/write_close.go:6 +0x63
exit status 2

dlv分析

先用前面类似方法找到函数入口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
(dlv) si
> runtime.chansend1() /usr/local/go/src/runtime/chan.go:126 (PC: 0x404300)
Warning: debugging optimized function
   121:         return add(c.buf, uintptr(i)*uintptr(c.elemsize))
   122: }
   123:
   124: // entry point for c <- x from compiled code
   125: //go:nosplit
=> 126: func chansend1(c *hchan, elem unsafe.Pointer) {
   127:         chansend(c, elem, true, getcallerpc())
   128: }
   129:
   130: /*
   131:  * generic single channel send/recv

持续n和si找到

1
2
3
4
5
6
7
8
9
10
11
12
13
14
(dlv) n
> runtime.chansend() /usr/local/go/src/runtime/chan.go:186 (PC: 0x40483b)
Warning: debugging optimized function
   181:         }
   182:
   183:         lock(&c.lock)
   184:
   185:         if c.closed != 0 {
=> 186:                 unlock(&c.lock)
   187:                 panic(plainError("send on closed channel"))
   188:         }
   189:
   190:         if sg := c.recvq.dequeue(); sg != nil {
   191:                 // Found a waiting receiver. We pass the value we want to send

可以看到在runtime/chan.go的185行有相关检查panic

Close closed

代码

1
2
3
4
5
6
7
package main

func main() {
	ch := make(chan int)
	close(ch)
	close(ch)
}

报错提示

1
2
3
4
5
6
7
# go run close_closed.go
panic: close of closed channel

goroutine 1 [running]:
main.main()
        /work/close_closed/close_closed.go:6 +0x57
exit status 2

dlv分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
(dlv) n
> runtime.closechan() /usr/local/go/src/runtime/chan.go:347 (PC: 0x404d20)
Warning: debugging optimized function
   342:                 panic(plainError("close of nil channel"))
   343:         }
   344:
   345:         lock(&c.lock)
   346:         if c.closed != 0 {
=> 347:                 unlock(&c.lock)
   348:                 panic(plainError("close of closed channel"))
   349:         }
   350:
   351:         if raceenabled {
   352:                 callerpc := getcallerpc()

可以看到在runtime/chan.go的346行有相关检查panic

选做：修复test case

作业内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
package mapexpr

import (
	"go/ast"
	"go/parser"
	"go/token"
	"testing"

	"github.com/stretchr/testify/assert"
)

// Eval : 判断 map 是否符合 bool 表达式
//	expr = `a > 1 && b < 0`
func Eval(m map[string]string, expr string) (bool, error) {
	fset := token.NewFileSet()
	exprAst, err := parser.ParseExpr(expr)
	if err != nil {
		return false, err
	}

	ast.Print(fset, exprAst)
	return judge(exprAst, m), nil
}

func isLeaf(bop ast.Node) bool {
	expr, ok := bop.(*ast.BinaryExpr)
	if !ok {
		return false
	}
	_, okL := expr.X.(*ast.Ident)
	_, okR := expr.Y.(*ast.BasicLit)
	if okL && okR {
		return true
	}
	return false
}

// dfs
func judge(bop ast.Node, m map[string]string) bool {
	if isLeaf(bop) {
		// do the leaf logic
		expr := bop.(*ast.BinaryExpr)
		x := expr.X.(*ast.Ident)
		y := expr.Y.(*ast.BasicLit)

		// FIXME，修正这里的逻辑，使 test 能够正确通过
		return m[x.Name] == y.Value
	}

	// not leaf
	// 那么一定是 binary expression
	expr, ok := bop.(*ast.BinaryExpr)
	if !ok {
		println("this cannot be true")
		return false
	}

	switch expr.Op {
	case token.LAND:
		return judge(expr.X, m) && judge(expr.Y, m)
	case token.LOR:
		return judge(expr.X, m) || judge(expr.Y, m)
	}

	println("unsupported operator")
	return false
}

type testCase struct {
	m      map[string]string
	expr   string
	result bool
}

func TestMapExpr(t *testing.T) {
	cases := []testCase{
		testCase{
			m: map[string]string{
				"invest": "20000", "posts": "144",
			},
			expr:   `invest > 10000 && posts > 100`,
			result: true,
		},
	}

	for _, cas := range cases {
		res, err := Eval(cas.m, cas.expr)
		assert.Nil(t, err)
		assert.Equal(t, res, cas.result)
	}
}

运行结果

这个代码在go1.14.12中是无法运行的，由于 reflect.Value 类型没有 CanConvert 方法，以及 reflect.StructField 类型没有 IsExported 方法，这里改用本机的go1.21.0运行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
❯ go test ch02/fix_test/rule_match_test.go
     0  *ast.BinaryExpr {
     1  .  X: *ast.BinaryExpr {
     2  .  .  X: *ast.Ident {
     3  .  .  .  NamePos: -
     4  .  .  .  Name: "invest"
     5  .  .  }
     6  .  .  OpPos: -
     7  .  .  Op: >
     8  .  .  Y: *ast.BasicLit {
     9  .  .  .  ValuePos: -
    10  .  .  .  Kind: INT
    11  .  .  .  Value: "10000"
    12  .  .  }
    13  .  }
    14  .  OpPos: -
    15  .  Op: &&
    16  .  Y: *ast.BinaryExpr {
    17  .  .  X: *ast.Ident {
    18  .  .  .  NamePos: -
    19  .  .  .  Name: "posts"
    20  .  .  }
    21  .  .  OpPos: -
    22  .  .  Op: >
    23  .  .  Y: *ast.BasicLit {
    24  .  .  .  ValuePos: -
    25  .  .  .  Kind: INT
    26  .  .  .  Value: "100"
    27  .  .  }
    28  .  }
    29  }
--- FAIL: TestMapExpr (0.00s)
    rule_match_test.go:90:
                Error Trace:    /Users/windtrack/go/src/work/windtrack.xyz/go-learn/ch02/fix_test/rule_match_test.go:90
                Error:          Not equal:
                                expected: false
                                actual  : true
                Test:           TestMapExpr
FAIL
FAIL    command-line-arguments  2.289s
FAIL

报错分析

这里是因为表达式为大于，代码里只是判断是否相等，所以需要修改

代码修改

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// dfs
func judge(bop ast.Node, m map[string]string) bool {
	if isLeaf(bop) {
		// do the leaf logic
		expr := bop.(*ast.BinaryExpr)
		x := expr.X.(*ast.Ident)
		y := expr.Y.(*ast.BasicLit)

		// 支持了多种运算操作符
		switch expr.Op {
		case token.GTR:
			return m[x.Name] > y.Value
		case token.LEQ:
			return m[x.Name] <= y.Value
		case token.LSS:
			return m[x.Name] < y.Value
		case token.EQL:
			return m[x.Name] == y.Value
		case token.NEQ:
			return m[x.Name] != y.Value
		case token.GEQ:
			return m[x.Name] >= y.Value
		default:
			println("unsupported operator")
		}
	}

	// not leaf
	// 那么一定是 binary expression
	expr, ok := bop.(*ast.BinaryExpr)
	if !ok {
		println("this cannot be true")
		return false
	}

	switch expr.Op {
	case token.LAND:
		return judge(expr.X, m) && judge(expr.Y, m)
	case token.LOR:
		return judge(expr.X, m) || judge(expr.Y, m)
	}

	println("unsupported operator")
	return false
}

选做：分析go新版函数调用规约

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

Python后端开发，业余前端，自学CV中