go官网的7个例子分析

陆仁贾 · · 12580 次点击 · · 开始浏览

这是一个创建于的文章，其中的信息可能已经有所发展或是发生改变。

go 语言或是 golang 的官网首页上有 7 个例子代码，赶脚灰常好，赶脚值得写篇文章简单分析一下 —— 虽然第 6 个例子不是太懂，貌似是个玩游戏的。

hello,世界
1. package main
3. import "fmt"
5. func main() {
6. fmt.Println("Hello, 世界")
7. }
这是hello,世界程序，要比hello,world其实要难一些，因为里面有中文！windows 下直接运行这个程序一般都有错误或是乱码出现，主要是编码的问题，倒不是程序的问题（请使用 utf-8 编码程序以及终端！）。关于安装以及其他细节可以看这篇文章—— 介绍 windows 下 go 环境的搭建，不仅仅是安装一下的问题。

从这个例子中，可以看出来，go 是通过 package（包）来实现功能或是模块分割的；控制台/终端输出要借助于 fmt 包中的 Println 函数，或是 Printf 函数；使用包之前，先导入！虽然你也许可以直接使用 print/println 函数，但是不能保证永远可以用！

go 支持单独的函数使用。所以，go 更像是 c ！

程序从 main 包的 main 函数开始执行；但是 main 函数不接受参数（参数怎么处理？），没有返回值，而且貌似语句没有分号！分号实际跟 c 语言类似，是语句的分隔符，不过 go 有自动分号插入规则，所以很多时候，偶们都可以省略分号。
处理命令行参数
1. package main
3. import (
4. // "fmt"
5. "os"
6. "flag" // command line option parser
7. )
9. var nFlag = flag.Bool("n", true, "末尾是否换行")
11. func main() {
12. flag.Parse(); // 解析命令行选项
13. s := "";
14. for i := 0; i < flag.NArg(); i++ {
15. if i > 0 {
16. s += " " // 单词之间用空格间隔开来
17. }
18. s += flag.Arg(i)
19. }
20. if *nFlag { // 换行与否
21. s += "\n"
22. }
23. // fmt.Println(flag.Args());
24. os.Stdout.WriteString(s);
25. }
27. // results in cmd:
28. > go run hello.go -n=false good morning
29. good morning
30. > go run hello.go -n=true good morning
31. good moring
33. > go run hello.go good morning
34. good moring
36. >
这个是从上面的那个——如何处理命令行参数——问题衍生出来的程序。 main 函数不像 c/c++/java 等带有参数可以处理命令行参数，go 有自己的方法。

flag 包负责处理命令行参数。这里实现的一个类似 echo 的命令，将命令行参数一个一个输出，对于最后是否换行，我们来个选项 -n=false 或是 -n=true 来决定；默认带有换行。

flag.Bool 就是获取这个 -n 选项，true/false ？使用参数前使用 flag.Parse 获取这些选项和参数，然后可以使用 flag.Args() 这个片段来处理参数，或是使用 flag.NArg() 和 flag.Arg(i) —— 一个是长度，一个是具体的值，来进行处理。
这里使用的是 os 包的 Stdout.WriteString 进行的输出，也可以使用 fmt 包中的函数进行输出。
斐波拉契闭包
1. package main
3. // fib returns a function that returns
4. // successive Fibonacci numbers.
5. func fib() func() int {
6. a, b := 0, 1
7. return func() int {
8. a, b = b, a+b
9. return a
10. }
11. }
13. func main() {
14. f := fib()
15. // Function calls are evaluated left-to-right.
16. println(f(), f(), f(), f(), f())
17. }
斐波拉契跟闭包其实嚒神马关系！斐波拉契数列是灰常出名的数列：1、1、2、3、5、8、13、...；从第三个数开始每个数均是前面两个数的和，而前两个数都是 1。习惯 c、c++ 等语言的话，e 们一般会用个循环来迭代求；go 当然也可以，不过这里使用的闭包的技术，鄙人赶脚是很巧妙的用法。

fib 是个函数，它有两个局部变量 a、b，返回值是个函数，这个函数使用着 a、b；返回值是函数现在很多语言都支持或是准备支持了，javascript、F#等等。按 c 语言的传统，函数调用完，局部（自动）变量 a、b 销毁，不能使用；然而在 go 中当 fib 返回的函数中一直在使用 fib 中的两个局部/临时变量 —— 这实际就是闭包，然后会发生神马情况呢？会将这两个变量的生存期延长，也就是说只要返回的函数还有用，这两个变量就在使用；所以，第一次调用 f、第二次调用 f 都在使用这两个变量，这两个变量的值也一直在变化，每调用一次 f ，f 返回的 a 就是一个斐波拉契数，调用几次就返回第几个 Fibonacci 数。

程序逻辑就是上面所说，不过这个例子还说明 go 的函数声明的问题，func 表明是个函数，然后写函数名，加上参数，而函数的返回值类型写在后面；函数名如果么有的话，那就是匿名函数！
皮亚诺整数
1. // Peano integers are represented by a linked
2. // list whose nodes contain no data
3. // (the nodes are the data).
4. // http://en.wikipedia.org/wiki/Peano_axioms
6. // This program demonstrates the power of Go's
7. // segmented stacks when doing massively
8. // recursive computations.
10. package main
12. import "fmt"
14. // Number is a pointer to a Number
15. type Number *Number
17. // The arithmetic value of a Number is the
18. // count of the nodes comprising the list.
19. // (See the count function below.)
21. // -------------------------------------
22. // Peano primitives
24. func zero() *Number {
25. return nil
26. }
28. func isZero(x *Number) bool {
29. return x == nil
30. }
32. func add1(x *Number) *Number {
33. e := new(Number)
34. *e = x
35. return e
36. }
38. func sub1(x *Number) *Number {
39. return *x
40. }
42. func add(x, y *Number) *Number {
43. if isZero(y) {
44. return x
45. }
46. return add(add1(x), sub1(y))
47. }
49. func mul(x, y *Number) *Number {
50. if isZero(x) || isZero(y) {
51. return zero()
52. }
53. return add(mul(x, sub1(y)), x)
54. }
56. func fact(n *Number) *Number {
57. if isZero(n) {
58. return add1(zero())
59. }
60. return mul(fact(sub1(n)), n)
61. }
63. // -------------------------------------
64. // Helpers to generate/count Peano integers
66. func gen(n int) *Number {
67. if n > 0 {
68. return add1(gen(n - 1))
69. }
70. return zero()
71. }
73. func count(x *Number) int {
74. if isZero(x) {
75. return 0
76. }
77. return count(sub1(x)) + 1
78. }
80. // -------------------------------------
81. // Print i! for i in [0,9]
83. func main() {
84. for i := 0; i <= 9; i++ {
85. f := count(fact(gen(i)))
86. fmt.Println(i, "! =", f)
87. }
88. }
这是一个 n！的例子，但又不是单单的一个求 n！的例子；这个例子让 e 们赶脚到了 —— 自然数可以构造出来或是一一数出来！“皮亚诺自然数公理”：0 是一个自然数；每个自然数后面都跟有一个自然数；除 0 之外，每个自然数前面都有一个自然数；—— 0 很特殊，是第一个自然数，因为它前面没有自然数！同时例子中也反映了：阶乘依赖于自然数乘法；自然数乘法依赖于自然数加法，而自然数加法其实是个递归定义。

自然数就是一个链表，链表的第一个元素代表 0 ，第二个元素代表 1，第三个代表 2，一直下去。10 就是一个长度为 10 的链表！求 10！的思路不再是循环一下，乘一下！而是，构造出一个长度是 10！的链表，然后 count 一下长度，就是 10！多此一举？！这里所有的操作只建立在“加一”、“减一”和“递归”的基础之上。
并发求圆周率 π
1. // Concurrent computation of pi.
2. // See http://goo.gl/ZuTZM.
3. //
4. // This demonstrates Go's ability to handle
5. // large numbers of concurrent processes.
6. // It is an unreasonable way to calculate pi.
7. package main
9. import (
10. "fmt"
11. "math"
12. )
14. func main() {
15. fmt.Println(pi(5000))
16. }
18. // pi launches n goroutines to compute an
19. // approximation of pi.
20. func pi(n int) float64 {
21. ch := make(chan float64)
22. for k := 0; k <= n; k++ {
23. go term(ch, float64(k))
24. }
25. f := 0.0
26. for k := 0; k <= n; k++ {
27. f += <-ch
28. }
29. return f
30. }
32. func term(ch chan float64, k float64) {
33. ch <- 4 * math.Pow(-1, k) / (2*k + 1)
34. }
割圆术求圆周长或是圆周率，听的比较多，but，太不切实可行！不管公式怎么来的，总之有下面一个公式，本例子就是用这个公式求 π ：

例子中使用了并发求每单项的值，然后将每单项的值加起来，赶脚是，加的项数越多，便越接近与真值。

go 中的管道（channel）提供了一种很方便的并发同步机制。管道是连接多个并发函数的通道，就像是水管，一端可以流进去，另一端可以流出去。这里多个函数/进程将每个单项的求值放到管道之后，谁先谁后是不确定的，然后另外一个函数/进程从管道中取值然后加起来，最后的结果便是就得的 π 的近似值。管道的同步操作已经内置，也就是不需要偶们自己去管来的。 go 是偶目前看到的写并发程序最容易的语言，么有之一！
并发通过筛选法求素数
1. // A concurrent prime sieve
3. package main
5. // Send the sequence 2, 3, 4, ... to channel 'ch'.
6. func Generate(ch chan<- int) {
7. for i := 2; ; i++ {
8. ch <- i // Send 'i' to channel 'ch'.
9. }
10. }
12. // Copy the values from channel 'in' to channel 'out',
13. // removing those divisible by 'prime'.
14. func Filter(in <-chan int, out chan<- int, prime int) {
15. for {
16. i := <-in // Receive value from 'in'.
17. if i%prime != 0 {
18. out <- i // Send 'i' to 'out'.
19. }
20. }
21. }
23. // The prime sieve: Daisy-chain Filter processes.
24. func main() {
25. ch := make(chan int) // Create a new channel.
26. go Generate(ch) // Launch Generate goroutine.
27. for i := 0; i < 10; i++ {
28. prime := <-ch
29. print(prime, "\n")
30. ch1 := make(chan int)
31. go Filter(ch, ch1, prime)
32. ch = ch1
33. }
34. }

筛选法找素数是个不错的方法，2、3、4、5、6、7、8、9、10 ... 这些数中，第一个数 2 是素数，取出来，然后将 2 的倍数全部去掉；剩下的第一个数 3 还是素数，再去掉所有 3 的倍数，一直进行下去，就能找到很多素数。本例子也就是用的这个方法。

具体逻辑是：第一个管道记录从2开始的自然数，取第一自然数/质数 2；然后第二个管道记录从第一个管道中过滤后的所有自然数，再取一个质数 3；第三个管道取第二个管道中过滤后的数，又得一个质数；所有的管道都是无限长的，只要程序嚒有终止，这些筛选/过滤便一直在进行着。

孔明棋
1. // This program solves the (English) peg
2. // solitaire board game.
3. // http://en.wikipedia.org/wiki/Peg_solitaire
5. package main
7. import "fmt"
9. const N = 11 + 1 // length of a row (+1 for \n)
11. // The board must be surrounded by 2 illegal
12. // fields in each direction so that move()
13. // doesn't need to check the board boundaries.
14. // Periods represent illegal fields,
15. // ● are pegs, and ○ are holes.
17. var board = []rune(
18. `...........
19. ...........
20. ....●●●....
21. ....●●●....
22. ..●●●●●●●..
23. ..●●●○●●●..
24. ..●●●●●●●..
25. ....●●●....
26. ....●●●....
27. ...........
28. ...........
29. `)
31. // center is the position of the center hole if
32. // there is a single one; otherwise it is -1.
33. var center int
35. func init() {
36. n := 0
37. for pos, field := range board {
38. if field == '○' {
39. center = pos
40. n++
41. }
42. }
43. if n != 1 {
44. center = -1 // no single hole
45. }
46. }
48. var moves int // number of times move is called
50. // move tests if there is a peg at position pos that
51. // can jump over another peg in direction dir. If the
52. // move is valid, it is executed and move returns true.
53. // Otherwise, move returns false.
54. func move(pos, dir int) bool {
55. moves++
56. if board[pos] == '●' && board[pos+dir] == '●' && board[pos+2*dir] == '○' {
57. board[pos] = '○'
58. board[pos+dir] = '○'
59. board[pos+2*dir] = '●'
60. return true
61. }
62. return false
63. }
65. // unmove reverts a previously executed valid move.
66. func unmove(pos, dir int) {
67. board[pos] = '●'
68. board[pos+dir] = '●'
69. board[pos+2*dir] = '○'
70. }
72. // solve tries to find a sequence of moves such that
73. // there is only one peg left at the end; if center is
74. // >= 0, that last peg must be in the center position.
75. // If a solution is found, solve prints the board after
76. // each move in a backward fashion (i.e., the last
77. // board position is printed first, all the way back to
78. // the starting board position).
79. func solve() bool {
80. var last, n int
81. for pos, field := range board {
82. // try each board position
83. if field == '●' {
84. // found a peg
85. for _, dir := range [...]int{-1, -N, +1, +N} {
86. // try each direction
87. if move(pos, dir) {
88. // a valid move was found and executed,
89. // see if this new board has a solution
90. if solve() {
91. unmove(pos, dir)
92. println(string(board))
93. return true
94. }
95. unmove(pos, dir)
96. }
97. }
98. last = pos
99. n++
100. }
101. }
102. // tried each possible move
103. if n == 1 && (center < 0 || last == center) {
104. // there's only one peg left
105. println(string(board))
106. return true
107. }
108. // no solution found for this board
109. return false
110. }
112. func main() {
113. if !solve() {
114. fmt.Println("no solution found")
115. }
116. fmt.Println(moves, "moves tried")
117. }
例子嚒看懂，不做分析；
二叉排序树的比较
1. // Go's concurrency primitives make it easy to
2. // express concurrent concepts, such as
3. // this binary tree comparison.
4. //
5. // Trees may be of different shapes,
6. // but have the same contents. For example:
7. //
8. // 4 6
9. // 2 6 4 7
10. // 1 3 5 7 2 5
11. // 1 3
12. //
13. // This program compares a pair of trees by
14. // walking each in its own goroutine,
15. // sending their contents through a channel
16. // to a third goroutine that compares them.
18. package main
20. import (
21. "fmt"
22. "math/rand"
23. )
25. // A Tree is a binary tree with integer values.
26. type Tree struct {
27. Left *Tree
28. Value int
29. Right *Tree
30. }
32. // Walk traverses a tree depth-first,
33. // sending each Value on a channel.
34. func Walk(t *Tree, ch chan int) {
35. if t == nil {
36. return
37. }
38. Walk(t.Left, ch)
39. ch <- t.Value
40. Walk(t.Right, ch)
41. }
43. // Walker launches Walk in a new goroutine,
44. // and returns a read-only channel of values.
45. func Walker(t *Tree) <-chan int {
46. ch := make(chan int)
47. go func() {
48. Walk(t, ch)
49. close(ch)
50. }()
51. return ch
52. }
54. // Compare reads values from two Walkers
55. // that run simultaneously, and returns true
56. // if t1 and t2 have the same contents.
57. func Compare(t1, t2 *Tree) bool {
58. c1, c2 := Walker(t1), Walker(t2)
59. for {
60. v1, ok1 := <-c1
61. v2, ok2 := <-c2
62. if !ok1 || !ok2 {
63. return ok1 == ok2
64. }
65. if v1 != v2 {
66. break
67. }
68. }
69. return false
70. }
72. // New returns a new, random binary tree
73. // holding the values 1k, 2k, ..., nk.
74. func New(n, k int) *Tree {
75. var t *Tree
76. for _, v := range rand.Perm(n) {
77. t = insert(t, (1+v)*k)
78. }
79. return t
80. }
82. func insert(t *Tree, v int) *Tree {
83. if t == nil {
84. return &Tree{nil, v, nil}
85. }
86. if v < t.Value {
87. t.Left = insert(t.Left, v)
88. return t
89. }
90. t.Right = insert(t.Right, v)
91. return t
92. }
94. func main() {
95. t1 := New(100, 1)
96. fmt.Println(Compare(t1, New(100, 1)), "Same Contents")
97. fmt.Println(Compare(t1, New(99, 1)), "Differing Sizes")
98. fmt.Println(Compare(t1, New(100, 2)), "Differing Values")
99. fmt.Println(Compare(t1, New(101, 2)), "Dissimilar")
100. }
二叉排序树，首先是二叉树，其次，中序遍历的序列是有序序列。这里要比较两棵树是不是序列相同，只需要将中序遍历结果对比一下就可以了。

管道放置二叉排序树的中序遍历结果；程序中貌似主要用了递归。