转自:http://blog.csdn.net/delphiwcdj/article/details/16903649
本文通过对A Tour of Go的实践,总结Go语言的基础用法。
1 Go语言”奇怪用法“有哪些?
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,函数闭包的使用,闭包是一个匿名函数值,会引用到其外部的变量。
/* gerryyang * 2013-11-23 */ package main import ( "fmt" "math" "math/big" "math/cmplx" "math/rand" "net/http" "os" "runtime" "time" ) // Outside a function, every construct begins with a keyword (var, func, and so on) and the := construct is not available // The var statement declares a list of variables; as in function argument lists, the type is last var x, y, z int var c, python, java bool // A var declaration can include initializers, one per variable var x1, y1, z1 int = 1, 2, 3 // If an initializer is present, the type can be omitted; the variable will take the type of the initializer var c1, python1, java1 = true, false, "no!" // basic types // bool // string // int int8 int16 int32 int64 // uint uint8 uint16 uint32 uint64 uintptr // byte (alias for uint8) // rune (alias for int32, represents a Unicode code point) // float32 float64 // complex64 complex128 var ( ToBe bool = false MaxInt uint64 = 1<<64 - 1 complex complex128 = cmplx.Sqrt(-5 + 12i) ) // Constants are declared like variables, but with the const keyword const Pi = 3.14 // Constants can be character, string, boolean, or numeric values const World = "世界" // Numeric Constants const ( Big = 1 << 100 Small = Big >> 99 // 2 ) type Vertex struct { X int Y int } type Vertex2 struct { Lat, Long float64 } var m map[string]Vertex2 // Map literals are like struct literals, but the keys are required var m2 = map[string]Vertex2{ "gerryyang": Vertex2{ 100, 200, }, "wcdj": Vertex2{ -300, 500, }, } // If the top-level type is just a type name, you can omit it from the elements of the literal var m3 = map[string]Vertex2{ "math": {20, 40}, "computer": {30, 50}, } type Vertex3 struct { X, Y float64 } type MyFloat float64 type Abser interface { Abs() float64 } //////////////////////////////////////////////////////// func main() { fmt.Println("Hello Golang, I'm gerryyang") fmt.Println("The time is", time.Now()) // To see a different number, seed the number generator; see rand.Seed fmt.Println("My favorite number is", rand.Intn(7)) fmt.Printf("Now you have %g problesms\n", math.Nextafter(2, 3)) // In Go, a name is exported if it begins with a capital letter fmt.Println(math.Pi) // Notice that the type comes after the variable name fmt.Println(add(42, 13)) fmt.Println(add2(42, 13)) // multiple results a, b := swap("gerry", "yang") fmt.Println(a, b) // named return fmt.Println(split(17)) fmt.Println(split2(17)) // var used fmt.Println(x, y, z, c, python, java) fmt.Println(x1, y1, z1, c1, python1, java1) // Inside a function, the := short assignment statement can be used in place of a var declaration with implicit type var x2, y2, z2 int = 1, 2, 3 c2, python2, java2 := true, false, "yes!" fmt.Println(x2, y2, z2, c2, python2, java2) // basic types const f = "%T(%v)\n" fmt.Printf(f, ToBe, ToBe) fmt.Printf(f, MaxInt, MaxInt) fmt.Printf(f, complex, complex) // Constants cannot be declared using the := syntax const World2 = "和平" const Truth = true fmt.Println(Pi) fmt.Println("你好", World) fmt.Println("世界", World2) fmt.Println("Go rules?", Truth) // Numeric Constants fmt.Println(needInt(Small)) ////fmt.Println(needInt(Big))// error, constant 1267650600228229401496703205376 overflows int ////fmt.Println(needInt64(Big)) // error, same as above ////fmt.Println(needBigInt(big.NewInt(Big)))// error, 使用big.Int貌似入参最大类型只支持int64 fmt.Println(needFloat(Small)) fmt.Println(needFloat(Big)) // Go has only one looping construct, the for loop // 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 sum := 0 for i := 0; i < 10; i++ { sum += i } fmt.Println(sum) // As in C or Java, you can leave the pre and post statements empty // At that point you can drop the semicolons: C's while is spelled for in Go sum1 := 1 for sum1 < 1000 { sum1 += sum1 } fmt.Println(sum1) // If you omit the loop condition it loops forever, so an infinite loop is compactly expressed ivar := 1 for { if ivar++; ivar > 1000 { fmt.Println("leave out an infinite loop") break } } // The if statement looks as it does in C or Java, except that the ( ) are gone and the { } are required fmt.Println(sqrt(2), sqrt(-4)) // Like for, the if statement can start with a short statement to execute before the condition fmt.Println(pow(3, 2, 10), pow(3, 3, 20)) // If and else fmt.Println(pow2(3, 2, 10), pow2(3, 3, 20)) //////////////////////////////////////////////////////////// // A struct is a collection of fields fmt.Println(Vertex{1, 2}) // Struct fields are accessed using a dot v := Vertex{1, 2} v.X = 4 fmt.Println(v) // Go has pointers, but no pointer arithmetic // Struct fields can be accessed through a struct pointer. The indirection through the pointer is transparent p := Vertex{1, 2} q := &p q.X = 1e9 fmt.Println(p) // struct literals // A struct literal denotes a newly allocated struct value by listing the values of its fields p = Vertex{1, 2} // has type Vertex q = &Vertex{1, 2} // has type * Vertex r := Vertex{X: 1} // Y:0 is implicit s := Vertex{} // X:0 and Y:0 fmt.Println(p, q, r, s) // The expression new(T) allocates a zeroed T value and returns a pointer to it // var t *T = new(T) or t := new(T) pv := new(Vertex) fmt.Println(pv) pv.X, pv.Y = 11, 9 fmt.Println(pv) // A slice points to an array of values and also includes a length // []T is a slice with elements of type T as := []int{2, 3, 5, 7, 11, 13} fmt.Println("as ==", as) for i := 0; i < len(as); i++ { fmt.Printf("as[%d] == %d\n", i, as[i]) } // Slices can be re-sliced, creating a new slice value that points to the same array // The expression: s[lo:hi] // evaluates to a slice of the elements from lo through hi-1, inclusive fmt.Println("as[1:4] ==", as[1:4]) // missing low index implies 0 fmt.Println("as[:3] ==", as[:3]) // missing high index implies len(s) fmt.Println("as[4:] ==", as[4:]) // Slices are created with the make function. It works by allocating a zeroed array and returning a slice that refers to that array // a := make([]int, 5), note, len(a) = 5 // To specify a capacity, pass a third argument to make // b := make([]int, 0 , 5), note, len(b) = 0, cap(b) = 5 // b = b[:cap(b)], note, len(b) = 5, cap(b) = 5 // b = b[1:], note, len(b) = 4, cap(b) = 4 s1 := make([]int, 5) printSlice("s1", s1) s2 := make([]int, 0, 5) printSlice("s2", s2) s3 := s2[:2] printSlice("s3", s3) s4 := s3[2:5] printSlice("s4", s4) // The zero value of a slice is nil // A nil slice has a length and capacity of 0 var s5 []int fmt.Println(s5, len(s5), cap(s5)) if s5 == nil { fmt.Println("slice is nil") } // The range form of the for loop iterates over a slice or map var s6 = []int{1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024} for i, v := range s6 { fmt.Printf("2**%d = %d\n", i, v) } // If you only want the index, drop the ", value" entirely for i := range s6 { s6[i] = 1 << uint(i) } // You can skip the index or value by assigning to _ for _, value := range s6 { fmt.Printf("%d\n", value) } // A map maps keys to values // Maps must be created with make (not new) before use; the nil map is empty and cannot be assigned to m = make(map[string]Vertex2) m["Bell Labs"] = Vertex2{ 40.68433, -74.39967, } fmt.Println(m["Bell Labs"]) // Map literals are like struct literals, but the keys are required fmt.Println(m2) // If the top-level type is just a type name, you can omit it from the elements of the literal fmt.Println(m3) // map // insert, update, retrieve, delete, test m4 := make(map[string]int) m4["date"] = 20131129 fmt.Println("The value:", m4["date"]) m4["date"] = m4["date"] + 1 fmt.Println("The value:", m4["date"]) date, ok := m4["date"] fmt.Println("The value:", date, "Present?", ok) delete(m4, "date") fmt.Println("The value:", m4["date"]) date2, ok := m4["date"] fmt.Println("The value:", date2, "Present?", ok) // Function values // Functions are values too hypot := func(x, y float64) float64 { return math.Sqrt(x*x + y*y) } fmt.Println(hypot(3, 4)) // Function closures // For example, the adder function returns a closure. Each closure is bound to its own sum variable pos, neg := adder(), adder() for i := 0; i < 10; i++ { fmt.Println(pos(i), neg(-2*i)) } // fibonacci fib := fibonacci() for i := 0; i < 10; i++ { fmt.Println(fib()) } // switch // A case body breaks automatically, unless it ends with a fallthrough statement switch os := runtime.GOOS; os { case "darwin": fmt.Println("OS X") case "linux": fmt.Println("Linux") default: // freebsd, openbsd // plan9, windows... fmt.Printf("%s", os) } // Switch cases evaluate cases from top to bottom, stopping when a case succeeds // Note: Time in the Go playground always appears to start at 2009-11-10 23:00:00 UTC fmt.Println("When's Saturday?") today := time.Now().Weekday() switch time.Saturday { case today + 0: fmt.Println("Today") case today + 1: fmt.Println("Tomorrow") case today + 2: fmt.Println("In two days") case today + 3: fmt.Println("In three days") default: fmt.Println("Too far away") } // Switch without a condition is the same as switch true // This construct can be a clean way to write long if-then-else chains t_now := time.Now() switch { case t_now.Hour() < 12: fmt.Println("Good morning!") case t_now.Hour() < 17: fmt.Println("Good afternoon") default: fmt.Println("Good evening") } // Go does not have classes. However, you can define methods on struct types v3 := &Vertex3{3, 4} fmt.Println(v3.Abs()) // In fact, you can define a method on any type you define in your package, not just structs // You cannot define a method on a type from another package, or on a basic type f1 := MyFloat(-math.Sqrt2) fmt.Println(f1.Abs()) // Methods with pointer receivers // Methods can be associated with a named type or a pointer to a named type // We just saw two Abs methods. One on the *Vertex pointer type and the other on the MyFloat value type // 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 v3 = &Vertex3{3, 4} v3.Scale(5) fmt.Println(v3, v3.Abs()) // An interface type is defined by a set of methods // A value of interface type can hold any value that implements those methods var a_interface Abser v4 := Vertex3{3, 4} a_interface = f1 // a MyFloat implements Abser a_interface = &v4 // a *Vertex3 implements Abser //a_interface = v4 // a Vertex3, does Not, error! fmt.Println(a_interface.Abs()) // Interfaces are satisfied implicitly var w Writer // os.Stdout implements Writer w = os.Stdout fmt.Fprintf(w, "hello, writer\n") // 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 } if err := run(); err != nil { fmt.Println(err) } // Web servers //var h Hello //http.ListenAndServe("localhost:4000", h) } ///////////////////////////////////////////// // func can be used before declare func add(x int, y int) int { return x + y } // When two or more consecutive named function parameters share a type, you can omit the type from all but the last func add2(x, y int) int { return x + y } // multiple results, a function can return any number of results func swap(x, y string) (string, string) { return y, x } // In Go, functions can return multiple "result parameters", not just a single value. They can be named and act just like variables func split(sum int) (x, y int) { x = sum * 4 / 9 y = sum - x return y, x } // In Go, functions can return multiple "result parameters", not just a single value. They can be named and act just like variables func split2(sum int) (x, y int) { x = sum * 4 / 9 y = sum - x // If the result parameters are named, a return statement without arguments returns the current values of the results return } func needInt(x int) int { return x*10 + 1 } func needInt64(x int64) int64 { return x*10 + 1 } func needBigInt(x *big.Int) (result *big.Int) { result = new(big.Int) result.Set(x) result.Mul(result, big.NewInt(10)) return } func needFloat(x float64) float64 { return x * 0.1 } func sqrt(x float64) string { if x < 0 { return sqrt(-x) + "i" } return fmt.Sprint(math.Sqrt(x)) } // Variables declared by the statement are only in scope until the end of the if func pow(x, n, lim float64) float64 { if v := math.Pow(x, n); v < lim { return v } return lim } // Variables declared inside an if short statement are also available inside any of the else blocks func pow2(x, n, lim float64) float64 { if v := math.Pow(x, n); v < lim { return v } else { fmt.Printf("%g >= %g\n", v, lim) } // can't use v here, though return lim } func printSlice(s string, x []int) { fmt.Printf("%s len = %d cap = %d %v\n", s, len(x), cap(x), x) } // 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 func adder() func(int) int { sum := 0 return func(x int) int { sum += x return sum } } // fibonacci is a function that returns // a function that returns an int. func fibonacci() func() int { p := 0 q := 1 s := 0 return func() int { s = p + q p = q q = s return s } } // The method receiver appears in its own argument list between the func keyword and the method name func (v *Vertex3) Abs() float64 { return math.Sqrt(v.X*v.X + v.Y*v.Y) } func (f MyFloat) Abs() float64 { if f < 0 { fmt.Println("f < 0 here") return float64(-f) } return float64(f) } // Methods with pointer receivers func (v *Vertex3) Scale(f float64) { v.X = v.X * f v.Y = v.Y * f } // Interfaces are satisfied implicitly type Reader interface { Read(b []byte) (n int, err error) } type Writer interface { Write(b []byte) (n int, err error) } type ReadWriter interface { Reader Writer } // error control type MyError struct { When time.Time What string } func (e *MyError) Error() string { return fmt.Sprintf("at %v, %s", e.When, e.What) } func run() error { return &MyError{ time.Now(), "it didn't work", } } // Web servers type Hello struct{} func (h Hello) ServeHTTP( w http.ResponseWriter, r *http.Request) { fmt.Fprint(w, "gerryyang") } /* output: Hello Golang, I'm gerryyang The time is 2013-12-04 22:52:01.336562598 +0800 HKT My favorite number is 6 Now you have 2.0000000000000004 problesms 3.141592653589793 55 55 yang gerry 10 7 7 10 0 0 0 false false false 1 2 3 true false no! 1 2 3 true false yes! bool(false) uint64(18446744073709551615) complex128((2+3i)) 3.14 你好 世界 世界 和平 Go rules? true 21 0.2 1.2676506002282295e+29 45 1024 leave out an infinite loop 1.4142135623730951 2i 9 20 27 >= 20 9 20 {1 2} {4 2} {1000000000 2} {1 2} &{1 2} {1 0} {0 0} &{0 0} &{11 9} as == [2 3 5 7 11 13] as[0] == 2 as[1] == 3 as[2] == 5 as[3] == 7 as[4] == 11 as[5] == 13 as[1:4] == [3 5 7] as[:3] == [2 3 5] as[4:] == [11 13] s1 len = 5 cap = 5 [0 0 0 0 0] s2 len = 0 cap = 5 [] s3 len = 2 cap = 5 [0 0] s4 len = 3 cap = 3 [0 0 0] [] 0 0 slice is nil 2**0 = 1 2**1 = 2 2**2 = 4 2**3 = 8 2**4 = 16 2**5 = 32 2**6 = 64 2**7 = 128 2**8 = 256 2**9 = 512 2**10 = 1024 1 2 4 8 16 32 64 128 256 512 1024 {40.68433 -74.39967} map[gerryyang:{100 200} wcdj:{-300 500}] map[math:{20 40} computer:{30 50}] The value: 20131129 The value: 20131130 The value: 20131130 Present? true The value: 0 The value: 0 Present? false 5 0 0 1 -2 3 -6 6 -12 10 -20 15 -30 21 -42 28 -56 36 -72 45 -90 1 2 3 5 8 13 21 34 55 89 OS X When's Saturday? In three days Good evening 5 f < 0 here 1.4142135623730951 &{15 20} 25 5 hello, writer at 2013-12-04 22:52:01.337206342 +0800 HKT, it didn't work */
有疑问加站长微信联系(非本文作者)