go官网的7个例子分析

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

1. 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 有自动分号插入规则,所以很多时候,偶们都可以省略分号。

2. 处理命令行参数
   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 包中的函数进行输出。

3. 斐波拉契闭包
   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 表明是个函数,然后写函数名,加上参数,而函数的返回值类型写在后面;函数名如果么有的话,那就是匿名函数!

4. 皮亚诺整数
   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!多此一举?!这里所有的操作只建立在"加一"、"减一"和"递归"的基础之上。

5. 并发求圆周率 π
   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 是偶目前看到的写并发程序最容易的语言,么有之一!

6. 并发通过筛选法求素数
   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;第三个管道取第二个管道中过滤后的数,又得一个质数;所有的管道都是无限长的,只要程序嚒有终止,这些筛选/过滤便一直在进行着。

7. 孔明棋
   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. }

   例子嚒看懂,不做分析;

8. 二叉排序树的比较
   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. }

   二叉排序树,首先是二叉树,其次,中序遍历的序列是有序序列。这里要比较两棵树是不是序列相同,只需要将中序遍历结果对比一下就可以了。

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

文章维护中...

本文来自:陆仁贾个人站点

感谢作者:陆仁贾

查看原文:go官网的7个例子分析

• 编辑
• 预览