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() {
//創(chuàng)建一個零值的結(jié)構(gòu)體件炉，不是nil凌净，可以給它賦值
var emp7 Employee
emp7.firstName = "Jack"
emp7.lastName = "Adams"
fmt.Println("Employee 7:", emp7)
}
