golang基礎練習（一）

//遍歷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)
}