golang基礎練習(一)
阿新 • • 發佈:2018-11-03
//遍歷map package main import "fmt" func main() { x := make(map[string]int) x["zhangsan"] = 3 x["lisi"] = 4 x["wangwu"] = 5 //#丟棄值 for i,_ := range x { fmt.Println(i) } } //匿名函式 package main import "fmt" func main() { f := func(x, y int) int{ return x + y } fmt.Println(f(2,3)) } //defer 延遲執行,後進先出 //用法:執行關閉 package main import "fmt" func main() { for i := 1; i <= 5; i++{ defer fmt.Println(i) } fmt.Println("before defer") } //defer 延遲執行 package main import "fmt" func main() { defer func() { fmt.Print("after defer") }() fmt.Println("before defer") } //異常 package main import "fmt" func main() { defer func() { fmt.Print("after defer") }() panic("I am wrong~!") fmt.Println("before defer") } //函式作為一種資料型別 package main import "fmt" func main() { type sum func(x, y int) int var f sum = func(x, y int) int { return x + y } fmt.Println(f(3, 4)) } //struct,struct有繼承的特性 package main import "fmt" type Person struct { name string age int } type Student struct { Person speciality string } func main() { student := Student{Person{"zhangsan", 23}, "maths"} person := Person{"zhangsan",23} fmt.Printf("%v", person.name) fmt.Printf("%v", student.speciality) } //return package main import "fmt" func split(sum int) (x, y int) { x = sum * 4 / 9 y = sum - x // 單獨使用return,返回所有返回值 return } func main() { fmt.Println(split(17)) } //Variables package main import "fmt" //一行宣告多個變數,並且也可以賦值多個變數 //整型預設值0,bool型別預設false // var c, python, java bool var one, two, three int var s1, s2, s3 string //下面演示一個錯誤的示範,函式主機外不能賦值 //s1, s2, s3 = "string1", "string2", "string3" func main() { var i int fmt.Println(i, c, python, java) fmt.Println(i, one, two, three) s1, s2, s3 = "string1", "string2", "string3" fmt.Println(s1, s2, s3) } //Variables with initializers package main import "fmt" var i, j int = 1, 2 func main() { //golang直接宣告賦值一步到位 var c, python, java = true, false, "no!" fmt.Println(i, j, c, python, java) } //Short variable declarations package main import "fmt" func main() { var i, j int = 1, 2 k := 3 c, python, java := true, false, "no!" fmt.Println(i, j, k, c, python, java) } //Basic types package main import ( "fmt" "math/cmplx" ) //宣告相同的資料型別,可以用()一起申明 var ( ToBe bool = false MaxInt uint64 = 1<<64 - 1 z complex128 = cmplx.Sqrt(-5 + 12i) ) //printf函式中%T輸出資料型別 func main() { fmt.Printf("Type: %T Value: %v\n", ToBe, ToBe) fmt.Printf("Type: %T Value: %v\n", MaxInt, MaxInt) fmt.Printf("Type: %T Value: %v\n", z, z) } //Zero values package main import "fmt" func main() { var i int var f float64 var b bool var s string fmt.Printf("%v %v %v %q\n", i, f, b, s) } //Type conversions package main import ( "fmt" "math" ) func main() { var x, y int = 3, 4 var v float64 = 5.0111 fmt.Println(v) var f float64 = math.Sqrt(float64(x*x + y*y)) b := int(v) var z uint = uint(f) fmt.Println(x, y, z,b) } //Type inference //編譯器自行推理資料型別 package main import "fmt" func main() { v := 42 // change me! s := "hello world" fmt.Printf("v is of type %T %T\n", v, s) } //Constants //Constants cannot be declared using the := syntax. package main import "fmt" const Pi = 3.14 func main() { const World = "世界" fmt.Println("Hello", World) fmt.Println("Happy", Pi, "Day") const Truth = true fmt.Println("Go rules?", Truth) } //Numeric Constants package main import "fmt" const ( // Create a huge number by shifting a 1 bit left 100 places. // In other words, the binary number that is 1 followed by 100 zeroes. Big = 1 << 100 // Shift it right again 99 places, so we end up with 1<<1, or 2. Small = Big >> 99 ) func needInt(x int) int { return x*10 + 1 } func needFloat(x float64) float64 { return x * 0.1 } func main() { fmt.Println(needInt(Small)) fmt.Println(needFloat(Small)) fmt.Println(needFloat(Big)) } //for package main import "fmt" func main() { sum := 0 for i := 0; i < 100; i++ { fmt.Println(i) sum += i } fmt.Println("sum:", sum) } //For continued //The init and post statements are optional. package main import "fmt" func main() { sum := 1 for ; sum < 1000; { sum += sum fmt.Println(sum) } fmt.Println(sum) } //For is Go's "while" //At that point you can drop the semicolons: C's while is spelled for in Go. //需要將迴圈終止條件放在程式碼語句中 package main import "fmt" func main() { sum := 1 for sum < 1000 { sum += sum } fmt.Println(sum) } //Forever // /If you omit the loop condition it loops forever, so an infinite loop is compactly expressed. package main func main() { for { } } //If package main import ( "fmt" "math" ) func sqrt(x float64) string { if x < 0 { return sqrt(-x) + "i" } return fmt.Sprint(math.Sqrt(x)) } func main() { fmt.Println(sqrt(2), sqrt(-4)) } //If with a short statement package main import ( "fmt" "math" ) //傳入的引數通過math函式功能得出結果後同lim做條件判斷 func pow(x, n, lim float64) float64 { if v := math.Pow(x, n); v < lim { return v } return lim } func main() { fmt.Println( pow(3, 2, 10), pow(3, 3, 20), ) } //Switch evaluation order package main import ( "fmt" "time" ) func main() { fmt.Println("When's Wednesday?") today := time.Now().Weekday() fmt.Println("Today:", today) switch time.Wednesday { case today + 0: fmt.Println("Today.") case today + 1: fmt.Println("Tomorrow.") case today + 2: fmt.Println("In two days.") default: fmt.Println("Too far away.") } } //Switch with no condition //Switch without a condition is the same as switch true.This construct can be a clean way to write long if-then-else chains. package main import ( "fmt" "time" ) func main() { t := time.Now() switch { case t.Hour() < 12: fmt.Println("Good morning!") case t.Hour() < 17: fmt.Println("Good afternoon.") default: fmt.Println("Good evening.") } } // Defer //延遲執行 package main import "fmt" func main() { defer fmt.Println("world") fmt.Println("hello") fmt.Println("world") fmt.Println("say once again") fmt.Println("hello") } //Stacking defers //Deferred function calls are pushed onto a stack. When a function returns, its deferred calls are executed in last-in-first-out order. //後進先出規則 package main import "fmt" func main() { fmt.Println("counting") for i := 0; i < 10; i++ { defer fmt.Println(i) } fmt.Println("done") } //Pointers //The type *T is a pointer to a T value. Its zero value is nil. //The & operator generates a pointer to its operand. package main import "fmt" func main() { i, j := 42, 2701 p := &i // point to i fmt.Println(&i) fmt.Println(&p) fmt.Println(*p) // read i through the pointer *p = 21 // set i through the pointer fmt.Println(i) // see the new value of i p = &j // point to j *p = *p / 37 // divide j through the pointer fmt.Println(j) // see the new value of j fmt.Println(&j) } //Structs. A struct is a collection of fields. package main import "fmt" type Vertex struct { X int Y int } func main() { fmt.Println(Vertex{1, 2}) } //Struct Fields. Struct fields are accessed using a dot. package main import "fmt" type Vertex struct { X int Y int } func main() { v := Vertex{1, 2} v.X = 4 fmt.Println(v.X) } //Pointers to structs 通過結構體指標可以訪問結構體欄位,注意被訪問的變數要大寫 //Struct fields can be accessed through a struct pointer. package main import "fmt" type Vertex struct { X int Y int } func main() { v := Vertex{1, 2} p := &v p.X = 100 fmt.Println(v) } //Struct Literals package main import "fmt" type Vertex struct { X, Y int } var ( v1 = Vertex{1, 2} // has type Vertex v2 = Vertex{X: 2} // Y:0 is implicit v3 = Vertex{} // X:0 and Y:0 v4 = Vertex{Y:5} p = &Vertex{1, 2} // has type *Vertex ) func main() { fmt.Println(v1, p, v2, v3, v4) } // Arrays //The type [n]T is an array of n values of type T. /* The expression var a [10]int */ package main import "fmt" func main() { var a [2]string a[0] = "Hello" a[1] = "World" fmt.Println(a[0], a[1]) fmt.Println(a) primes := [6]int{2, 3, 5, 7, 11, 13} fmt.Println(primes) bb :=[2]bool{false, true} fmt.Println(bb) } //Slices //An array has a fixed size. A slice, on the other hand, is a dynamically-sized, flexible view into the elements of an array. In practice, slices are much more common than arrays. //The type []T is a slice with elements of type T. package main import "fmt" //[1:4]以閉區間開始,開區間結束 func main() { primes := [6]int{2, 3, 5, 7, 11, 13} var s []int = primes[1:4] fmt.Println(s) } //Slices are like references to arrays /* A slice does not store any data, it just describes a section of an underlying array. Changing the elements of a slice modifies the corresponding elements of its underlying array. Other slices that share the same underlying array will see those changes. */ package main import "fmt" func main() { names := [4]string{ "John", "Paul", "George", "Ringo", } fmt.Println(names) a := names[0:2] b := names[1:3] fmt.Println(a, b) b[0] = "XXX" fmt.Println(a, b) fmt.Println(names) } // Slice literals package main import "fmt" func main() { q := []int{2, 3, 5, 7, 11, 13} fmt.Println(q) r := []bool{true, false, true, true, false, true} fmt.Println(r) f := []float64{1.11111, 2.22222, 3.33333, 4.44444} fmt.Println(f) s := []struct { i int b bool }{ {2, true}, {3, false}, {5, true}, {7, true}, {11, false}, {13, true}, } fmt.Println(s) } //Slice defaults /* When slicing, you may omit the high or low bounds to use their defaults instead. The default is zero for the low bound and the length of the slice for the high bound. For the array var a [10]int these slice expressions are equivalent: a[0:10] a[:10] a[0:] a[:] */ package main import "fmt" func main() { s := []int{2, 3, 5, 7, 11, 13} s = s[1:4] fmt.Println(s) //從第0個元素到第1個元素結束 s = s[:2] fmt.Println(s) //從第一個元素開始,最後一個元素結束 s = s[1:] fmt.Println(s) } //Slice length and capacity //slice引用的是陣列中的記憶體地址,array在使用過程中是指傳遞 //A slice has both a length and a capacity. //The length of a slice is the number of elements it contains. // The capacity of a slice is the number of elements in the underlying array, counting from the first element in the slice. //切片的容量是潛在陣列的元素個數,從切片的第一個元素開始算起 //The length and capacity of a slice s can be obtained using the expressions len(s) and cap(s). //You can extend a slice's length by re-slicing it, provided it has sufficient capacity. Try changing one of the slice operations in the example program to extend it beyond its capacity and see what happens. package main import "fmt" func main() { s := []int{2, 3, 5, 7, 11, 13} printSlice(s) // Slice the slice to give it zero length. s = s[:1] printSlice(s) // Extend its length. s = s[:4] printSlice(s) // Drop its first two values. s = s[3:] printSlice(s) } func printSlice(s []int) { fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s) } // Nil slices /* The zero value of a slice is nil. A nil slice has a length and capacity of 0 and has no underlying array. 空切片的長度和容量為0,值為nil */ package main import "fmt" func main() { var s []int fmt.Println(s, len(s), cap(s)) if s == nil { fmt.Println("nil!") } } //Creating a slice with make /* Slices can be created with the built-in make function; this is how you create dynamically-sized arrays. The make function allocates a zeroed array and returns a slice that refers to that array: a := make([]int, 5) // len(a)=5 To specify a capacity, pass a third argument to make: b := make([]int, 0, 5) // len(b)=0, cap(b)=5 b = b[:cap(b)] // len(b)=5, cap(b)=5 b = b[1:] // len(b)=4, cap(b)=4 */ package main import "fmt" func main() { a := make([]int, 5) printSlice("a", a) b := make([]int, 0, 5) printSlice("b", b) c := b[:2] printSlice("c", c) d := c[2:5] printSlice("d", d) } func printSlice(s string, x []int) { fmt.Printf("%s len=%d cap=%d %v\n", s, len(x), cap(x), x) } //Slices of slices //Slices can contain any type, including other slices. //其實就是可動態變化的多維陣列 //計算機的思維去理解程式 package main import ( "fmt" "strings" ) func main() { // Create a tic-tac-toe board. board := [][]string{ []string{"_", "_", "_"}, []string{"_", "_", "_"}, []string{"_", "_", "_"}, } // The players take turns. board[0][0] = "X" board[0][1] = "X" board[1][2] = "X" board[1][0] = "O" board[1][1] = "0" board[1][2] = "0" board[0][2] = "X" for i := 0; i < len(board); i++ { fmt.Printf("%s\n", strings.Join(board[i], " ")) } } //Appending to a slice package main import "fmt" func main() { //定義一個空切片,長度和容量都為0 var s []int printSlice(s) // append works on nil slices. //在切片中追加一個元素,預設長度為1,容量為2 s = append(s, 0) printSlice(s) // The slice grows as needed. s = append(s, 1) printSlice(s) // We can add more than one element at a time. s = append(s, 2, 3, 4) printSlice(s) s = append(s, 5, 6, 7, 9) printSlice(s) } func printSlice(s []int) { fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s) } //Range /* The range form of the for loop iterates over a slice or map. When ranging over a slice, two values are returned for each iteration. The first is the index, and the second is a copy of the element at that index. */ package main import "fmt" var pow = []int{1, 2, 4, 8, 16, 32, 64, 128} func main() { for i, v := range pow { fmt.Printf("2**%d = %d\n", i, v) } } //simple add method package main import "fmt" var pow = []int{1, 2, 4, 8, 16, 32, 64, 128} var sum int = 0 func main() { for _, v := range pow { sum += v } fmt.Println(sum) } //Range continued //You can skip the index or value by assigning to _. //If you only want the index, drop the , value entirely. //你可以跳過索引的遍歷,或者只是想要遍歷索引,那麼把後面的, value去掉 package main import "fmt" func main() { //使用make函式宣告一個整型切片,變數名為pow pow := make([]int, 32) for i := range pow { pow[i] = 1 << uint(i) // == 2**i fmt.Printf("%d\n", i) } for _, value := range pow { fmt.Printf("%d\n", value) } } //Exercise: Slices //how to use slice in code? // Maps package main import "fmt" type Vertex struct { Lat, Long float64 } type NbaPlayers struct { lastname, firstname string } //宣告一個map型別變數m var m map[string]Vertex //宣告一個map型別變數n var n map[string]NbaPlayers var b map[string]int func main() { m = make(map[string]Vertex) n = make(map[string]NbaPlayers) b = make(map[string]int) m["Bell Labs"] = Vertex{ 40.68433, -74.39967, } n["nba superstart"] = NbaPlayers{"Lebron", "James"} b["string"] = 1 fmt.Println(m["Bell Labs"]) fmt.Println(n["nba superstart"]) fmt.Println(b["string"]) } //Map literals //Map literals are like struct literals, but the keys are required. package main import "fmt" type Vertex struct { Lat, Long float64 } type Person struct { height int hair string } var m = map[string]Vertex{ "Bell Labs": Vertex{ 40.68433, -74.39967, }, "Google": Vertex{ 37.42202, -122.08408, }, } var n = map[string]Person{ "michael":Person{ 172, "black", }, "coco":Person{ 165, "brown", }, } func main() { fmt.Println(m) fmt.Println(n) } //Map literals continued //If the top-level type is just a type name, you can omit it from the elements of the literal. //如果頂級型別僅僅是type型別,你可以從文字元素中省略type型別。 package main import "fmt" type Vertex struct { Lat, Long float64 } type Person struct { height int hair string } var m = map[string]Vertex{ "Bell Labs": {40.68433, -74.39967}, "Google": {37.42202, -122.08408}, } var n = map[string]Person{ "michael":{ 172, "black", }, "coco":{ 165, "brown", }, } func main() { fmt.Println(m) fmt.Println(n) } //Mutating Maps 改變map型別 //Insert or update an element in map m: package main import "fmt" func main() { n := make(map[string]string) n["Players"] = "Kobe" n["Players"] = "James" fmt.Println("The value", n["Players"]) //空字元預設為" " delete(n, "Players") fmt.Println("The value:", n["Players"]) m := make(map[string]int) m["Answer"] = 42 fmt.Println("The value:", m["Answer"]) m["Answer"] = 48 fmt.Println("The value:", m["Answer"]) //空數字為0 delete(m, "Answer") fmt.Println("The value:", m["Answer"]) m["Answer"] = 60 //如果key“Answer”在m map中,那麼ok就是true v, ok := m["Answer"] fmt.Println("The value:", v, "Present?", ok) } //Exercise: Maps //how to use maps in code? //Function values //Functions are values too. They can be passed around just like other values. //Function values may be used as function arguments and return values. package main import ( "fmt" "math" ) func compute(fn func(float64, float64) float64) float64 { return fn(3, 4) } func main() { hypot := func(x, y float64) float64 { return math.Sqrt(x*x + y*y) } fmt.Println(hypot(5, 12)) fmt.Println(compute(hypot)) fmt.Println(compute(math.Pow)) } //Function closures // //Methods package main import ( "fmt" "math" ) type Vertex struct { X, Y float64 } func (v Vertex) Abs() float64 { return math.Sqrt(v.X*v.X + v.Y*v.Y) } func main() { v := Vertex{3, 4} fmt.Println(v.Abs()) } //Methods are functions //Remember: a method is just a function with a receiver argument. //記住:一個方法就是帶著接收者引數的函式。 //Here's Abs written as a regular function with no change in functionality. package main import ( "fmt" "math" ) type Vertex struct { X, Y float64 } func Abs(v Vertex) float64 { return math.Sqrt(v.X*v.X + v.Y*v.Y) } func main() { v := Vertex{3, 4} fmt.Println(Abs(v)) } //Methods continued //You can declare a method on non-struct types, too. package main import ( "fmt" "math" ) type MyFloat float64 func (f MyFloat) Abs() float64 { if f < 0 { return float64(-f) } return float64(f) } func main() { f := MyFloat(-math.Sqrt2) fmt.Println(f.Abs()) } //Pointer receivers package main import ( "fmt" "math" ) type Vertex struct { X, Y float64 } func (v Vertex) Abs() float64 { return math.Sqrt(v.X*v.X + v.Y*v.Y) } func (v *Vertex) Scale(f float64) { v.X = v.X * f v.Y = v.Y * f } func main() { v := Vertex{3, 4} v.Scale(10) fmt.Println(v.Abs()) } //Pointers and functions package main import ( "fmt" "math" ) type Vertex struct { X, Y float64 } func Abs(v Vertex) float64 { return math.Sqrt(v.X*v.X + v.Y*v.Y) } func Scale(v *Vertex, f float64) { v.X = v.X * f v.Y = v.Y * f } func main() { v := Vertex{3, 4} Scale(&v, 10) fmt.Println(Abs(v)) } //Methods and pointer indirection package main import "fmt" type Vertex struct { X, Y float64 } func (v *Vertex) Scale(f float64) { v.X = v.X * f v.Y = v.Y * f } func ScaleFunc(v *Vertex, f float64) { v.X = v.X * f v.Y = v.Y * f } func main() { v := Vertex{3, 4} v.Scale(2) ScaleFunc(&v, 10) p := &Vertex{4, 3} p.Scale(3) ScaleFunc(p, 8) fmt.Println(v, p) }