Go疑难杂症

channel

package main

import "fmt"

func main() {
    c := make(chan int, 10)
    quit := make(chan int)
    go func() {
        size := cap(c)
        for i := 0; i < size; i++ {
            fmt.Println(<-c)
        }
        quit <- 0
    }()
    fibonacci(c, quit)
}

func fibonacci(ch, quit chan int) {
    x, y := 1, 1
    for {
        select {
        case ch <- x:
            x, y = y, x+y
        case <-quit:
            fmt.Println("quit")
        default:
            break
        }
    }

}

package main

import "time"

func main() {
    c := make(chan int)
    o := make(chan bool)
    go func() {
        for {
            select {
            case v := <- c:
                println(v)
            case <- time.After(5 * time.Second):
                println("timeout")
                o <- true
                break
            }
        }
    }()
    <- o
}

反射

package main

import (
    "fmt"
    "reflect"
    "strings"
)

type order struct {
    ordId      int
    customerId int
}

type employee struct {
    id      int
    name    string
    address string
    salary  int
    country string
}

func createQuery(q interface{}) {
    if reflect.ValueOf(q).Kind() == reflect.Struct {
        t := reflect.TypeOf(q).Name()
        query := fmt.Sprintf("insert into %s values(", t)
        v := reflect.ValueOf(q)
        for i := 0; i < v.NumField(); i++ {
            switch v.Field(i).Kind() {
            case reflect.Int:
                if i == 0 {
                    query = fmt.Sprintf("%s%d", query, v.Field(i).Int())
                } else {
                    query = fmt.Sprintf("%s, %d", query, v.Field(i).Int())
                }
            case reflect.String:
                if i == 0 {
                    query = fmt.Sprintf("%s\"%s\"", query, v.Field(i).String())
                } else {
                    query = fmt.Sprintf("%s, \"%s\"", query, v.Field(i).String())
                }
            default:
                fmt.Println("Unsupported type")
                return
            }
        }
        query = fmt.Sprintf("%s)", query)
        fmt.Println(query)
        return
    }

    fmt.Println("unsupported type")
}

func update(q interface{}) {
    if reflect.ValueOf(q).Kind() == reflect.Struct {
        t := reflect.TypeOf(q).Name()
        sql := fmt.Sprintf("Update %s set", t)
        v := reflect.ValueOf(q)
        size := v.NumField()
        for i := 0; i < size; i++ {
            s := strings.ToUpper(v.Type().Field(i).Name)
            switch v.Field(i).Kind() {
            case reflect.Int:
                if i == 0 {
                    sql = fmt.Sprintf("%s %s = %d", sql, s, v.Field(i).Int())
                } else {
                    sql = fmt.Sprintf("%s and %s = %d", sql, s, v.Field(i).Int())
                }
            case reflect.String:
                if i == 0 {
                    sql = fmt.Sprintf("%s %s = %s", sql, s, v.Field(i).String())
                } else {
                    sql = fmt.Sprintf("%s and %s = %s", sql, s, v.Field(i).String())
                }
            }
        }
        fmt.Println(sql)
    }
}

func main() {
    o := order{
        ordId:      456,
        customerId: 56,
    }
    createQuery(o)
    update(o)

    e := employee{
        id:      565,
        name:    "Naveen",
        address: "Coimbatore",
        salary:  90000,
        country: "India",
    }
    createQuery(e)
    update(e)
    i := 90
    createQuery(i)

}

Mutex

package main

import (
    "fmt"
    "sync"
)

var x = 0

func increment(wg *sync.WaitGroup, mutex *sync.Mutex) {
    mutex.Lock()
    x = x + 1
    mutex.Unlock()
    wg.Done()
}
func main() {
    var w sync.WaitGroup
    var m sync.Mutex
    for i := 0; i < 1000; i++ {
        w.Add(1)
        go increment(&w, &m)
    }
    w.Wait()
    fmt.Println("final value of x", x)
}

channel

package main

import (
    "fmt"
    "sync"
)

var x = 0

func increment(wg *sync.WaitGroup, ch chan bool) {
    ch <- true
    x = x + 1
    <-ch
    wg.Done()
}
func main() {
    var w sync.WaitGroup
    ch := make(chan bool, 1)
    for i := 0; i < 1000; i++ {
        w.Add(1)
        go increment(&w, ch)
    }
    w.Wait()
    fmt.Println("final value of x", x)
}

package main

import (
    "fmt"
)

func change(s ...string) {
    s[0] = "Go"
    s = append(s, "playground")
    fmt.Println(s)
}

func main() {
    welcome := []string{"hello", "world"}
    change(welcome...)
    fmt.Println(welcome)
}

package main

import (
    "fmt"
)

func mutate(s []rune) string {
    s[0] = 'a'
    return string(s)
}
func main() {
    h := "hello"
    fmt.Println(mutate([]rune(h)))
}

So forget about passing pointers to arrays around and use slices instead

package main

import (
    "fmt"
)

func modify(sls []int) {
    sls[0] = 90
}

func main() {
    a := [3]int{89, 90, 91}
    modify(a[:])
    fmt.Println(a)
}

It is also possible to create a zero struct and then assign values to its fields later.

package main

import (  
    "fmt"
)

type Employee struct {  
    firstName, lastName string
    age, salary         int
}

func main() {  
    //创建一个零值的结构体，不是nil，可以给它赋值
    var emp7 Employee
    emp7.firstName = "Jack"
    emp7.lastName = "Adams"
    fmt.Println("Employee 7:", emp7)
}