go语言 接口组合空接口
Go语言
2014-09-18 11:22:42 newsyoung1 阅读数 1027

最近在学习并用go语言编程,发现go语言蛮好玩也挺有意思

 

Go语言”奇怪用法“实践总结

本文通过对A Tour of Go的实践,总结Go语言的基础用法。

 

1 Go语言”奇怪用法“有哪些?


1,go的变量声明顺序是:”先写变量名,再写类型名“,此与C/C++的语法孰优孰劣,可见下文解释:
http://blog.golang.org/gos-declaration-syntax

2,go是通过package来组织的(与python类似),只有package名为main的包可以包含main函数,一个可执行程序有且仅有一个main包,通过import关键字来导入其他非main包。

3,可见性规则。go语言中,使用大小写来决定该常量、变量、类型、接口、结构或函数是否可以被外部包含调用。根据约定,函数名首字母小写即为private,函数名首字母大写即为public。

4,go内置关键字(25个均为小写)。

5,函数不用先声明,即可使用。

6,在函数内部可以通过 := 隐士定义变量。(函数外必须显示使用var定义变量)

7,go程序使用UTF-8编码的纯Unicode文本编写。

8,使用big.Int的陷阱:
http://stackoverflow.com/questions/11270547/go-big-int-factorial-with-recursion

9,从技术层面讲,go语言的语句是以分号分隔的,但这些是由编译器自动添加的,不用手动输入,除非需要在同一行中写入多个语句。没有分号及只需少量的逗号和圆括号,使得go语言的程序更容易阅读。

10,go语言只有一个循环结构——for循环。

11,go里的自增运算符只有——“后++”

12,go语言中的slice用法类似python中数组,关于slice的详细用法可见:http://blog.golang.org/go-slices-usage-and-internals

13,函数也是一个值,使用匿名函数返回一个值。

14,函数闭包的使用,闭包是一个匿名函数值,会引用到其外部的变量。



2 代码实践


  1. /* gerryyang 
  2.  * 2013-11-23 
  3.  */  
  4.   
  5. package main  
  6.   
  7. import (  
  8.     "fmt"  
  9.     "math"  
  10.     "math/big"  
  11.     "math/cmplx"  
  12.     "math/rand"  
  13.     "net/http"  
  14.     "os"  
  15.     "runtime"  
  16.     "time"  
  17. )  
  18.   
  19. // Outside a function, every construct begins with a keyword (var, func, and so on) and the := construct is not available  
  20. // The var statement declares a list of variables; as in function argument lists, the type is last  
  21. var x, y, z int  
  22. var c, python, java bool  
  23.   
  24. // A var declaration can include initializers, one per variable  
  25. var x1, y1, z1 int = 1, 2, 3  
  26.   
  27. // If an initializer is present, the type can be omitted; the variable will take the type of the initializer  
  28. var c1, python1, java1 = truefalse"no!"  
  29.   
  30. // basic types  
  31. // bool  
  32. // string  
  33. // int int8 int16 int32 int64  
  34. // uint uint8 uint16 uint32 uint64 uintptr  
  35. // byte (alias for uint8)  
  36. // rune (alias for int32, represents a Unicode code point)  
  37. // float32 float64  
  38. // complex64 complex128  
  39. var (  
  40.     ToBe    bool       = false  
  41.     MaxInt  uint64     = 1<<64 - 1  
  42.     complex complex128 = cmplx.Sqrt(-5 + 12i)  
  43. )  
  44.   
  45. // Constants are declared like variables, but with the const keyword  
  46. const Pi = 3.14  
  47.   
  48. // Constants can be character, string, boolean, or numeric values  
  49. const World = "世界"  
  50.   
  51. // Numeric Constants  
  52. const (  
  53.     Big   = 1 << 100  
  54.     Small = Big >> 99 // 2  
  55. )  
  56.   
  57. type Vertex struct {  
  58.     X int  
  59.     Y int  
  60. }  
  61.   
  62. type Vertex2 struct {  
  63.     Lat, Long float64  
  64. }  
  65.   
  66. var m map[string]Vertex2  
  67.   
  68. // Map literals are like struct literals, but the keys are required  
  69. var m2 = map[string]Vertex2{  
  70.     "gerryyang": Vertex2{  
  71.         100, 200,  
  72.     },  
  73.     "wcdj": Vertex2{  
  74.         -300, 500,  
  75.     },  
  76. }  
  77.   
  78. // If the top-level type is just a type name, you can omit it from the elements of the literal  
  79. var m3 = map[string]Vertex2{  
  80.     "math":     {20, 40},  
  81.     "computer": {30, 50},  
  82. }  
  83.   
  84. type Vertex3 struct {  
  85.     X, Y float64  
  86. }  
  87.   
  88. type MyFloat float64  
  89.   
  90. type Abser interface {  
  91.     Abs() float64  
  92. }  
  93.   
  94. ////////////////////////////////////////////////////////  
  95.   
  96. func main() {  
  97.     fmt.Println("Hello Golang, I'm gerryyang")  
  98.     fmt.Println("The time is", time.Now())  
  99.   
  100.     // To see a different number, seed the number generator; see rand.Seed  
  101.     fmt.Println("My favorite number is", rand.Intn(7))  
  102.     fmt.Printf("Now you have %g problesms\n", math.Nextafter(2, 3))  
  103.     // In Go, a name is exported if it begins with a capital letter  
  104.     fmt.Println(math.Pi)  
  105.   
  106.     // Notice that the type comes after the variable name  
  107.     fmt.Println(add(42, 13))  
  108.     fmt.Println(add2(42, 13))  
  109.   
  110.     // multiple results  
  111.     a, b := swap("gerry""yang")  
  112.     fmt.Println(a, b)  
  113.   
  114.     // named return  
  115.     fmt.Println(split(17))  
  116.     fmt.Println(split2(17))  
  117.   
  118.     // var used  
  119.     fmt.Println(x, y, z, c, python, java)  
  120.     fmt.Println(x1, y1, z1, c1, python1, java1)  
  121.   
  122.     // Inside a function, the := short assignment statement can be used in place of a var declaration with implicit type  
  123.     var x2, y2, z2 int = 1, 2, 3  
  124.     c2, python2, java2 := truefalse"yes!"  
  125.     fmt.Println(x2, y2, z2, c2, python2, java2)  
  126.   
  127.     // basic types  
  128.     const f = "%T(%v)\n"  
  129.     fmt.Printf(f, ToBe, ToBe)  
  130.     fmt.Printf(f, MaxInt, MaxInt)  
  131.     fmt.Printf(f, complex, complex)  
  132.   
  133.     // Constants cannot be declared using the := syntax  
  134.     const World2 = "和平"  
  135.     const Truth = true  
  136.     fmt.Println(Pi)  
  137.     fmt.Println("你好", World)  
  138.     fmt.Println("世界", World2)  
  139.     fmt.Println("Go rules?", Truth)  
  140.   
  141.     // Numeric Constants  
  142.     fmt.Println(needInt(Small))  
  143.     ////fmt.Println(needInt(Big))// error, constant 1267650600228229401496703205376 overflows int  
  144.     ////fmt.Println(needInt64(Big)) // error, same as above  
  145.     ////fmt.Println(needBigInt(big.NewInt(Big)))// error, 使用big.Int貌似入参最大类型只支持int64  
  146.     fmt.Println(needFloat(Small))  
  147.     fmt.Println(needFloat(Big))  
  148.   
  149.     // Go has only one looping construct, the for loop  
  150.     // The basic for loop looks as it does in C or Java, except that the ( ) are gone (they are not even optional) and the { } are required  
  151.     sum := 0  
  152.     for i := 0; i < 10; i++ {  
  153.         sum += i  
  154.     }  
  155.     fmt.Println(sum)  
  156.   
  157.     // As in C or Java, you can leave the pre and post statements empty  
  158.     // At that point you can drop the semicolons: C's while is spelled for in Go  
  159.     sum1 := 1  
  160.     for sum1 < 1000 {  
  161.         sum1 += sum1  
  162.     }  
  163.     fmt.Println(sum1)  
  164.   
  165.     // If you omit the loop condition it loops forever, so an infinite loop is compactly expressed  
  166.     ivar := 1  
  167.     for {  
  168.         if ivar++; ivar > 1000 {  
  169.             fmt.Println("leave out an infinite loop")  
  170.             break  
  171.         }  
  172.     }  
  173.   
  174.     // The if statement looks as it does in C or Java, except that the ( ) are gone and the { } are required  
  175.     fmt.Println(sqrt(2), sqrt(-4))  
  176.   
  177.     // Like for, the if statement can start with a short statement to execute before the condition  
  178.     fmt.Println(pow(3, 2, 10), pow(3, 3, 20))  
  179.   
  180.     // If and else  
  181.     fmt.Println(pow2(3, 2, 10), pow2(3, 3, 20))  
  182.   
  183.     ////////////////////////////////////////////////////////////  
  184.   
  185.     // A struct is a collection of fields  
  186.     fmt.Println(Vertex{1, 2})  
  187.   
  188.     // Struct fields are accessed using a dot  
  189.     v := Vertex{1, 2}  
  190.     v.X = 4  
  191.     fmt.Println(v)  
  192.   
  193.     // Go has pointers, but no pointer arithmetic  
  194.     // Struct fields can be accessed through a struct pointer. The indirection through the pointer is transparent  
  195.     p := Vertex{1, 2}  
  196.     q := &p  
  197.     q.X = 1e9  
  198.     fmt.Println(p)  
  199.   
  200.     // struct literals  
  201.     // A struct literal denotes a newly allocated struct value by listing the values of its fields  
  202.     p = Vertex{1, 2}  // has type Vertex  
  203.     q = &Vertex{1, 2} // has type * Vertex  
  204.     r := Vertex{X: 1} // Y:0 is implicit  
  205.     s := Vertex{}     // X:0 and Y:0  
  206.     fmt.Println(p, q, r, s)  
  207.   
  208.     // The expression new(T) allocates a zeroed T value and returns a pointer to it  
  209.     // var t *T = new(T) or t := new(T)  
  210.     pv := new(Vertex)  
  211.     fmt.Println(pv)  
  212.     pv.X, pv.Y = 11, 9  
  213.     fmt.Println(pv)  
  214.   
  215.     // A slice points to an array of values and also includes a length  
  216.     // []T is a slice with elements of type T  
  217.     as := []int{2, 3, 5, 7, 11, 13}  
  218.     fmt.Println("as ==", as)  
  219.     for i := 0; i < len(as); i++ {  
  220.         fmt.Printf("as[%d] == %d\n", i, as[i])  
  221.     }  
  222.   
  223.     // Slices can be re-sliced, creating a new slice value that points to the same array  
  224.     // The expression: s[lo:hi]  
  225.     // evaluates to a slice of the elements from lo through hi-1, inclusive  
  226.     fmt.Println("as[1:4] ==", as[1:4])  
  227.     // missing low index implies 0  
  228.     fmt.Println("as[:3] ==", as[:3])  
  229.     // missing high index implies len(s)  
  230.     fmt.Println("as[4:] ==", as[4:])  
  231.   
  232.     // Slices are created with the make function. It works by allocating a zeroed array and returning a slice that refers to that array  
  233.     // a := make([]int, 5), note, len(a) = 5  
  234.     // To specify a capacity, pass a third argument to make  
  235.     // b := make([]int, 0 , 5), note, len(b) = 0, cap(b) = 5  
  236.     // b = b[:cap(b)], note, len(b) = 5, cap(b) = 5  
  237.     // b = b[1:], note, len(b) = 4, cap(b) = 4  
  238.     s1 := make([]int, 5)  
  239.     printSlice("s1", s1)  
  240.     s2 := make([]int, 0, 5)  
  241.     printSlice("s2", s2)  
  242.     s3 := s2[:2]  
  243.     printSlice("s3", s3)  
  244.     s4 := s3[2:5]  
  245.     printSlice("s4", s4)  
  246.   
  247.     // The zero value of a slice is nil  
  248.     // A nil slice has a length and capacity of 0  
  249.     var s5 []int  
  250.     fmt.Println(s5, len(s5), cap(s5))  
  251.     if s5 == nil {  
  252.         fmt.Println("slice is nil")  
  253.     }  
  254.   
  255.     // The range form of the for loop iterates over a slice or map  
  256.     var s6 = []int{1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024}  
  257.     for i, v := range s6 {  
  258.         fmt.Printf("2**%d = %d\n", i, v)  
  259.     }  
  260.   
  261.     // If you only want the index, drop the ", value" entirely  
  262.     for i := range s6 {  
  263.         s6[i] = 1 << uint(i)  
  264.     }  
  265.     // You can skip the index or value by assigning to _  
  266.     for _, value := range s6 {  
  267.         fmt.Printf("%d\n", value)  
  268.     }  
  269.   
  270.     // A map maps keys to values  
  271.     // Maps must be created with make (not new) before use; the nil map is empty and cannot be assigned to  
  272.     m = make(map[string]Vertex2)  
  273.     m["Bell Labs"] = Vertex2{  
  274.         40.68433, -74.39967,  
  275.     }  
  276.     fmt.Println(m["Bell Labs"])  
  277.   
  278.     // Map literals are like struct literals, but the keys are required  
  279.     fmt.Println(m2)  
  280.   
  281.     // If the top-level type is just a type name, you can omit it from the elements of the literal  
  282.     fmt.Println(m3)  
  283.   
  284.     // map  
  285.     // insert, update, retrieve, delete, test  
  286.     m4 := make(map[string]int)  
  287.     m4["date"] = 20131129  
  288.     fmt.Println("The value:", m4["date"])  
  289.     m4["date"] = m4["date"] + 1  
  290.     fmt.Println("The value:", m4["date"])  
  291.     date, ok := m4["date"]  
  292.     fmt.Println("The value:", date, "Present?", ok)  
  293.   
  294.     delete(m4, "date")  
  295.     fmt.Println("The value:", m4["date"])  
  296.     date2, ok := m4["date"]  
  297.     fmt.Println("The value:", date2, "Present?", ok)  
  298.   
  299.     // Function values  
  300.     // Functions are values too  
  301.     hypot := func(x, y float64) float64 {  
  302.         return math.Sqrt(x*x + y*y)  
  303.     }  
  304.     fmt.Println(hypot(3, 4))  
  305.   
  306.     // Function closures  
  307.     // For example, the adder function returns a closure. Each closure is bound to its own sum variable  
  308.     pos, neg := adder(), adder()  
  309.     for i := 0; i < 10; i++ {  
  310.         fmt.Println(pos(i), neg(-2*i))  
  311.     }  
  312.   
  313.     // fibonacci  
  314.     fib := fibonacci()  
  315.     for i := 0; i < 10; i++ {  
  316.         fmt.Println(fib())  
  317.     }  
  318.   
  319.     // switch  
  320.     // A case body breaks automatically, unless it ends with a fallthrough statement  
  321.     switch os := runtime.GOOS; os {  
  322.     case "darwin":  
  323.         fmt.Println("OS X")  
  324.     case "linux":  
  325.         fmt.Println("Linux")  
  326.     default:  
  327.         // freebsd, openbsd  
  328.         // plan9, windows...  
  329.         fmt.Printf("%s", os)  
  330.     }  
  331.   
  332.     // Switch cases evaluate cases from top to bottom, stopping when a case succeeds  
  333.     // Note: Time in the Go playground always appears to start at 2009-11-10 23:00:00 UTC  
  334.     fmt.Println("When's Saturday?")  
  335.     today := time.Now().Weekday()  
  336.     switch time.Saturday {  
  337.     case today + 0:  
  338.         fmt.Println("Today")  
  339.     case today + 1:  
  340.         fmt.Println("Tomorrow")  
  341.     case today + 2:  
  342.         fmt.Println("In two days")  
  343.     case today + 3:  
  344.         fmt.Println("In three days")  
  345.     default:  
  346.         fmt.Println("Too far away")  
  347.     }  
  348.   
  349.     // Switch without a condition is the same as switch true  
  350.     // This construct can be a clean way to write long if-then-else chains  
  351.     t_now := time.Now()  
  352.     switch {  
  353.     case t_now.Hour() < 12:  
  354.         fmt.Println("Good morning!")  
  355.     case t_now.Hour() < 17:  
  356.         fmt.Println("Good afternoon")  
  357.     default:  
  358.         fmt.Println("Good evening")  
  359.     }  
  360.   
  361.     // Go does not have classes. However, you can define methods on struct types  
  362.     v3 := &Vertex3{3, 4}  
  363.     fmt.Println(v3.Abs())  
  364.   
  365.     // In fact, you can define a method on any type you define in your package, not just structs  
  366.     // You cannot define a method on a type from another package, or on a basic type  
  367.     f1 := MyFloat(-math.Sqrt2)  
  368.     fmt.Println(f1.Abs())  
  369.   
  370.     // Methods with pointer receivers  
  371.     // Methods can be associated with a named type or a pointer to a named type  
  372.     // We just saw two Abs methods. One on the *Vertex pointer type and the other on the MyFloat value type  
  373.     // There are two reasons to use a pointer receiver. First, to avoid copying the value on each method call (more efficient if the value type is a large struct). Second, so that the method can modify the value that its receiver points to  
  374.     v3 = &Vertex3{3, 4}  
  375.     v3.Scale(5)  
  376.     fmt.Println(v3, v3.Abs())  
  377.   
  378.     // An interface type is defined by a set of methods  
  379.     // A value of interface type can hold any value that implements those methods  
  380.     var a_interface Abser  
  381.     v4 := Vertex3{3, 4}  
  382.     a_interface = f1  // a MyFloat implements Abser  
  383.     a_interface = &v4 // a *Vertex3 implements Abser  
  384.     //a_interface = v4  // a Vertex3, does Not, error!  
  385.     fmt.Println(a_interface.Abs())  
  386.   
  387.     // Interfaces are satisfied implicitly  
  388.     var w Writer  
  389.     // os.Stdout implements Writer  
  390.     w = os.Stdout  
  391.     fmt.Fprintf(w, "hello, writer\n")  
  392.   
  393.     // An error is anything that can describe itself as an error string. The idea is captured by the predefined, built-in interface type, error, with its single method, Error, returning a string: type error interface { Error() string }  
  394.     if err := run(); err != nil {  
  395.         fmt.Println(err)  
  396.     }  
  397.   
  398.     // Web servers  
  399.     //var h Hello  
  400.     //http.ListenAndServe("localhost:4000", h)  
  401.   
  402. }  
  403.   
  404. /////////////////////////////////////////////  
  405.   
  406. // func can be used before declare  
  407. func add(x int, y intint {  
  408.     return x + y  
  409. }  
  410.   
  411. // When two or more consecutive named function parameters share a type, you can omit the type from all but the last  
  412. func add2(x, y intint {  
  413.     return x + y  
  414. }  
  415.   
  416. // multiple results, a function can return any number of results  
  417. func swap(x, y string) (string, string) {  
  418.     return y, x  
  419. }  
  420.   
  421. // In Go, functions can return multiple "result parameters", not just a single value. They can be named and act just like variables  
  422. func split(sum int) (x, y int) {  
  423.     x = sum * 4 / 9  
  424.     y = sum - x  
  425.     return y, x  
  426. }  
  427.   
  428. // In Go, functions can return multiple "result parameters", not just a single value. They can be named and act just like variables  
  429. func split2(sum int) (x, y int) {  
  430.     x = sum * 4 / 9  
  431.     y = sum - x  
  432.   
  433.     // If the result parameters are named, a return statement without arguments returns the current values of the results  
  434.     return  
  435. }  
  436.   
  437. func needInt(x intint       { return x*10 + 1 }  
  438. func needInt64(x int64) int64 { return x*10 + 1 }  
  439. func needBigInt(x *big.Int) (result *big.Int) {  
  440.     result = new(big.Int)  
  441.     result.Set(x)  
  442.     result.Mul(result, big.NewInt(10))  
  443.     return  
  444. }  
  445. func needFloat(x float64) float64 {  
  446.     return x * 0.1  
  447. }  
  448.   
  449. func sqrt(x float64) string {  
  450.     if x < 0 {  
  451.         return sqrt(-x) + "i"  
  452.     }  
  453.     return fmt.Sprint(math.Sqrt(x))  
  454. }  
  455.   
  456. // Variables declared by the statement are only in scope until the end of the if  
  457. func pow(x, n, lim float64) float64 {  
  458.     if v := math.Pow(x, n); v < lim {  
  459.         return v  
  460.     }  
  461.     return lim  
  462. }  
  463.   
  464. // Variables declared inside an if short statement are also available inside any of the else blocks  
  465. func pow2(x, n, lim float64) float64 {  
  466.     if v := math.Pow(x, n); v < lim {  
  467.         return v  
  468.     } else {  
  469.         fmt.Printf("%g >= %g\n", v, lim)  
  470.     }  
  471.     // can't use v here, though  
  472.     return lim  
  473. }  
  474.   
  475. func printSlice(s string, x []int) {  
  476.     fmt.Printf("%s len = %d cap = %d %v\n", s, len(x), cap(x), x)  
  477. }  
  478.   
  479. // Go functions may be closures. A closure is a function value that references variables from outside its body. The function may access and assign to the referenced variables; in this sense the function is "bound" to the variables  
  480. func adder() func(intint {  
  481.     sum := 0  
  482.     return func(x intint {  
  483.         sum += x  
  484.         return sum  
  485.     }  
  486. }  
  487.   
  488. // fibonacci is a function that returns  
  489. // a function that returns an int.  
  490. func fibonacci() func() int {  
  491.     p := 0  
  492.     q := 1  
  493.     s := 0  
  494.     return func() int {  
  495.         s = p + q  
  496.         p = q  
  497.         q = s  
  498.         return s  
  499.     }  
  500. }  
  501.   
  502. // The method receiver appears in its own argument list between the func keyword and the method name  
  503. func (v *Vertex3) Abs() float64 {  
  504.     return math.Sqrt(v.X*v.X + v.Y*v.Y)  
  505. }  
  506.   
  507. func (f MyFloat) Abs() float64 {  
  508.     if f < 0 {  
  509.         fmt.Println("f < 0 here")  
  510.         return float64(-f)  
  511.     }  
  512.     return float64(f)  
  513. }  
  514.   
  515. // Methods with pointer receivers  
  516. func (v *Vertex3) Scale(f float64) {  
  517.     v.X = v.X * f  
  518.     v.Y = v.Y * f  
  519. }  
  520.   
  521. // Interfaces are satisfied implicitly  
  522. type Reader interface {  
  523.     Read(b []byte) (n int, err error)  
  524. }  
  525. type Writer interface {  
  526.     Write(b []byte) (n int, err error)  
  527. }  
  528. type ReadWriter interface {  
  529.     Reader  
  530.     Writer  
  531. }  
  532.   
  533. // error control  
  534. type MyError struct {  
  535.     When time.Time  
  536.     What string  
  537. }  
  538.   
  539. func (e *MyError) Error() string {  
  540.     return fmt.Sprintf("at %v, %s", e.When, e.What)  
  541. }  
  542. func run() error {  
  543.     return &MyError{  
  544.         time.Now(),  
  545.         "it didn't work",  
  546.     }  
  547. }  
  548.   
  549. // Web servers  
  550. type Hello struct{}  
  551.   
  552. func (h Hello) ServeHTTP(  
  553.     w http.ResponseWriter,  
  554.     r *http.Request) {  
  555.     fmt.Fprint(w, "gerryyang")  
  556. }  
  557.   
  558.   
  559. /* 
  560. output: 
  561.  
  562. Hello Golang, I'm gerryyang 
  563. The time is 2013-12-04 22:52:01.336562598 +0800 HKT 
  564. My favorite number is 6 
  565. Now you have 2.0000000000000004 problesms 
  566. 3.141592653589793 
  567. 55 
  568. 55 
  569. yang gerry 
  570. 10 7 
  571. 7 10 
  572. 0 0 0 false false false 
  573. 1 2 3 true false no! 
  574. 1 2 3 true false yes! 
  575. bool(false) 
  576. uint64(18446744073709551615) 
  577. complex128((2+3i)) 
  578. 3.14 
  579. 你好 世界 
  580. 世界 和平 
  581. Go rules? true 
  582. 21 
  583. 0.2 
  584. 1.2676506002282295e+29 
  585. 45 
  586. 1024 
  587. leave out an infinite loop 
  588. 1.4142135623730951 2i 
  589. 9 20 
  590. 27 >= 20 
  591. 9 20 
  592. {1 2} 
  593. {4 2} 
  594. {1000000000 2} 
  595. {1 2} &{1 2} {1 0} {0 0} 
  596. &{0 0} 
  597. &{11 9} 
  598. as == [2 3 5 7 11 13] 
  599. as[0] == 2 
  600. as[1] == 3 
  601. as[2] == 5 
  602. as[3] == 7 
  603. as[4] == 11 
  604. as[5] == 13 
  605. as[1:4] == [3 5 7] 
  606. as[:3] == [2 3 5] 
  607. as[4:] == [11 13] 
  608. s1 len = 5 cap = 5 [0 0 0 0 0] 
  609. s2 len = 0 cap = 5 [] 
  610. s3 len = 2 cap = 5 [0 0] 
  611. s4 len = 3 cap = 3 [0 0 0] 
  612. [] 0 0 
  613. slice is nil 
  614. 2**0 = 1 
  615. 2**1 = 2 
  616. 2**2 = 4 
  617. 2**3 = 8 
  618. 2**4 = 16 
  619. 2**5 = 32 
  620. 2**6 = 64 
  621. 2**7 = 128 
  622. 2**8 = 256 
  623. 2**9 = 512 
  624. 2**10 = 1024 
  625. 1 
  626. 2 
  627. 4 
  628. 8 
  629. 16 
  630. 32 
  631. 64 
  632. 128 
  633. 256 
  634. 512 
  635. 1024 
  636. {40.68433 -74.39967} 
  637. map[gerryyang:{100 200} wcdj:{-300 500}] 
  638. map[math:{20 40} computer:{30 50}] 
  639. The value: 20131129 
  640. The value: 20131130 
  641. The value: 20131130 Present? true 
  642. The value: 0 
  643. The value: 0 Present? false 
  644. 5 
  645. 0 0 
  646. 1 -2 
  647. 3 -6 
  648. 6 -12 
  649. 10 -20 
  650. 15 -30 
  651. 21 -42 
  652. 28 -56 
  653. 36 -72 
  654. 45 -90 
  655. 1 
  656. 2 
  657. 3 
  658. 5 
  659. 8 
  660. 13 
  661. 21 
  662. 34 
  663. 55 
  664. 89 
  665. OS X 
  666. When's Saturday? 
  667. In three days 
  668. Good evening 
  669. 5 
  670. f < 0 here 
  671. 1.4142135623730951 
  672. &{15 20} 25 
  673. 5 
  674. hello, writer 
  675. at 2013-12-04 22:52:01.337206342 +0800 HKT, it didn't work 
  676.  
  677.  
  678.  
  679. */  
原文出自:http://blog.csdn.net/delphiwcdj/article/details/16903649

2017-11-29 12:11:59 s_842499467 阅读数 390

写在前面:
Go语言安装包:64位go语言安装包下载 密码:tjvk
GoIDE安装包:GoLand 密码:5rd5
安装之后验证是否安装成功:在cmd中输入go,看是否有反馈信息
配置一下Go的开发环境GOROOT,路径为Go语言安装目录


一. Go语言内置关键字

Go内置关键字

二. Go语言注释方法

  • //单行注释
  • /* */多行注释

三. 项目结构

  • Go程序是通过package来组织的
  • 只有package 名称为main的包可以包含main函数
  • 一个可执行程序有且仅有一个main包
    初步练习时可以使用这种结构
    初步练习

四. 程序结构

  1. package 包名
  2. import 要导入的包
  3. 多个包可以用import(包名1 包名2 …)
  4. 如果导入包但是并没有对包进行相关操作就会编译异常
  5. import another_name “包名” 为当前导入的包起别名
  6. const 用来定义常量
  7. var 用来定义全局变量
  8. type 定义普通的变量 语法:type variable_name int
  9. type 定义结构体类型 type variable_name struct{}
  10. type 定义接口类型 type variable_name interface{}
  11. main函数 func main(){}
    基本语句
    基础

五. 可见性规则

  1. 函数名首字母为小写则为private
  2. 函数名首字母为大写则为public
2017-09-28 11:28:54 wh201458501106 阅读数 246

一开始接触Go语言觉得它非常精简而高效,相对于Java来说是这样的


下载

搭建Go语言开发环境,我们第一部就需要下载Go的开发工具,这里我使用的是go1.9(官网下载 如果不行可以去国内社区下载 链接)。

开发工具包又分为安装版和压缩版。安装版是Mac和Windows特有的,他们的名字类似于:

  • go1.9.darwin-amd64.pkg
  • go1.9.windows-386.msi
  • go1.9.windows-amd64.msi

安装版,顾名思义,双击打开会出现安装向导,让你选择安装的路径,帮你设置好环境比安康等信息,比较省事方便一些。

压缩版的就是一个压缩文件,可以解压得到里面的内容,他们的名字类似于:

  • go1.9.darwin-amd64.tar.gz
  • go1.9.linux-386.tar.gz
  • go1.9.linux-amd64.tar.gz
  • go1.9.windows-386.zip
  • go1.9.windows-amd64.zip

压缩版我们下载后需要解压,然后自己移动到要存放的路径下,并且配置环境变量等信息,相比安装版来说,比较复杂一些,手动配置的比较多。

安装

Windows也有压缩版和安装版,又分为32和64位以供选择,不过目前大家都是64位,选择这个更好一些。

Window的压缩版是一个ZIP压缩包,下载后使用winrar等软件就可以解压,解压后要选择一个存放目录,比如c:\Go下,这个c:\Go就是Go的安装目录了,他里面有bin、src、doc等目录。

然后就是环境变量的配置,Window也和Linux一样分为针对所有用户的系统变量,和针对当前用户的用户变量设置,可以自行选择,比如系统变量,针对所有用户都有效。

以Window 7为例,右击我的电脑->属性会打开系统控制面板,然后在左侧找到高级系统设置点击打开,会在弹出的界面最下方看到环境变量按钮,点击它,就可以看到环境变量配置界面了。上半部分是用户变量配置,下半部分是系统变量配置。

我们在系统变量里点击新建,变量名输入GOROOT,变量值是我们刚刚安装的go路径c:\Go,这样就配置好了GO目录的安装路径了。

然后修改PATH系统变量,在变量值里添加%%GOROOT\bin路径,和其他PATH变量以;(分号,Linux下是冒号)分割即可。这样我们就可以在CMD里直接输入go命令使用了。

打开我们的终端,输入go version测试下,好了的话就可以看到输出的信息了。

Window的安装版相比来说就比较简单一些,双击就可以按照提示一步步安装,默认安装路径是c:\Go,并且会配置好PATH环境变量,可以直接打开CMD终端使用。

2017-07-15 10:47:54 u010131839 阅读数 439

社区

开源项目

Go 语言项目搜索:https://gowalker.org/

Go Walker 是一个可以在线生成并浏览 Go 项目 API 文档的 Web 服务器,目前已支持包括 GitHub 等代码托管平台。

编程练习

CodeWar提供多种语言的编程练习题,能够在线编译,以关卡的方式组织题目,寓教于乐。
实验楼提供在线操作系统,能够在linux环境下编程,还有各种语言的学习课程,可以边看教案边敲代码。

2016-11-14 19:07:40 YID_152 阅读数 495

第一章go的基本配置

学习要点

(1)go语言的发展和简介
(2)go语言的安装
(3)go的项目管理
(4)go的命令
(5)开发工具(组内用vim,有配好的vim)

反思:

(1)项目管理中三个目录分别是什么,有什么作用?
(2)命令bulid,install,run,区别是什么?应用场景是什么?
(3)go语言特点有什么?

第二章go语言的基础

学习要点

(1)变量声明,类型
(2)流程结构,函数

反思

(1)一个包怎么调用另一包的函数,go语言中公有性和私有性怎么表达?
(2)简单的介绍一下闭包使用场景,优缺点?
(3)map和array make的使用区别?
(4)defer的工作模式
(5)匿名函数的使用(难点)

例子

(1)设计一个包storage存储包,支持链式存储,数组存储,map存储三种方式,分别实现增删改查三种方式并在main测试。

第三章面向对象和并发

学习要点

(1)面向对象 属性&method
(2)接口
(3)并发&通信

反思

(1)go语言如何表现继承
(2)接口的优点,使用场景。
(3)并发通信采用什么消息机制。

例子

(1)做一个简单的搜索工具,输入目录,查找固定文件类型,记录文件路径,返回客户端
(2)做一个简单的C/S通信

总结:现在go的基本语法已经掌握,可以简单的编写东西。

还需要深入学习的时go的Web开发&json协议。

推荐一些中文网站

讲解go的基础知识:https://github.com/astaxie/build-web-application-with-golang/tree/master/zh

中文社区http://studygolang.com/

主讲go内部实现:https://github.com/polaris1119/The-Golang-Standard-Library-by-Example

go官网https://golang.org/

https://golang.org/doc/effective_go.html

推荐一些中文书籍:go语言编程,go的并发编程

没有更多推荐了,返回首页