golang编程实践总结

//key类型须支持==和!=运算符，不能为浮点数
var matchers = make(map[string]string)
ages := make(map[string]int)，ages := make(map[string]int){}  //空map

//slice语法创建
ages := map[string]int{
    "alice":   31,
    "charlie": 34,
}

访问元素：ages["alice"] = 33
if age, ok := ages["bob"]; !ok { /* ... */ }

//map中的元素不是变量，不能寻址
//遍历（遍历顺序不定）   // 迭代切片里的元素
for name, age := range ages {
    fmt.Printf("%s\t%d\n", name, age)
}

var arrInt [8]int
td := [...]int{0,4,5,2}
//数组引用（将数组引用或指针传入函数）
func toZero(p *[32]byte){
   for i := range p{
      p[i] = 0
   }
}
func toZero1(p *[32]byte){
   *p = [32]byte{}
}

var names []string
for name := range ages {
    names = append(names, name)
}
s := arr[:] //初始化切片为数组arr的引用

//提前给slice分配一个合适的大小，避免内存分配和拷贝
names := make([]string, 0, len(ages)) //创建一个空的slice，容量为len
//在函数间传递切片

type books struct {
    title string
    author string
    subject string
    id int
}
book := &books {
    title: "Go Lang",
    author: "peter"
}
book := books{"Go", "Peter"}

cStop := make(chan bool, 1)
    // Create an unbuffered channel.
    baton := make(chan int)

type public interface {
    Topic() string
    Message() *Message
    Ack() error
}

type publication struct {
    d amqp.Delivery
    m *Message
    t string
}
func (p *publication) Ack() error {
    return p.d.Ack(false)
}
func (p *publication) Topic() string {
    return p.t
}
func (p *publication) Message() *Message {
    return p.m
}
func (p publication) Message() *Message {
    return p.m
}

type PubSub struct {
    host string
}
type mock struct{}
//其中mock和PubSub都实现了Publish和Subscribe两个接口
    pubs := []publisher{
        pubsub.New("localhost"),
        &mock{},
    }
    for _, p := range pubs {
        p.Publish("key", "value")
        p.Subscribe("key")
    }

func add(x, y int) int {
    return x + y
}


func swap(x, y string) (string, string) {
    return y, x
}

func add(x, y int) (z int) { 
    z = x + y
    return
}

func sum(numbers ...int) int {
    s := 0
    for i := range numbers{
        s += i
    }
    return s
}

//匿名函数，闭包
    var v func(a int) int
    v = func(a int) int {
        return a * a
    }
    fmt.Println(v(6))
//两种写法
    v1 := func(i int) int {
        return i * i

    }
    fmt.Println(v1(7))

/*
继承
一个结构体嵌到另一个结构体，称作组合
匿名和组合的区别
如果一个struct嵌套了另一个匿名结构体，那么这个结构可以直接访问匿名结构体的方法，从而实现继承
如果一个struct嵌套了另一个【有名】的结构体，那么这个模式叫做组合
如果一个struct嵌套了多个匿名结构体，那么这个结构可以直接访问多个匿名结构体的方法，从而实现多重继承
*/
type Car struct {
    weight int
    name   string
}
func (p *Car) Run() {
    fmt.Println("running")
}
type Bike struct {
    Car
    cycles int
}

package main

import (
    "fmt"
)

type People struct{}

type People2 struct{}

func (p *People) ShowA() {
    fmt.Println("showA")
    p.ShowB()
}
func (p *People) ShowB() {
    fmt.Println("showB")
}

func (p *People) ShowC() {
    fmt.Println("showC")
}

func (p *People) ShowD() {
    fmt.Println("People:showD")
}

func (p *People2) ShowD() {
    fmt.Println("People2:showD")
}

type Teacher struct {
    People  //组合People
    People2 //组合People2
}

func (t *Teacher) ShowB() {
    fmt.Println("teacher showB")
}
func (t *Teacher) ShowC(arg string) {
    fmt.Println(arg)
}

func main() {
    t := Teacher{}

    //print showA
    //print showB
    t.ShowA()

    //print teacher showB
    t.ShowB()

    //print showB
    t.People.ShowB()

    //print test
    t.ShowC("test")

    //print showC
    t.People.ShowC()

    //因为组合方法中多次包含ShowD，所以调用时必须显示指定匿名方法
    //print People2:showD
    t.People2.ShowD()
}

//同步等待：
    var wg sync.WaitGroup
    wg.Add(2)
    defer wg.Done()
    wg.Wait()
    runtime.Gosched()
//原子操作：
    atomic.AddInt64(&counter, 1)
    time.Sleep(1 * time.Second)
    atomic.StoreInt64(&shutdown, 1)
    atomic.LoadInt64(&shutdown)
//加锁：
    mutex.Lock()
    mutex.Unlock()

//随机数：
    rand.Seed(time.Now().UnixNano())
    n := rand.Intn(100)    

    /*
    1.runner包，调度后台处理任务，监视程序执行时间 【for-select结构】
            通过执行返回可判断是超时、系统中断还是正常完成任务
    2.pool包，有缓冲的通道实现资源池，管理多个协程间共享及独立使用的资源。[一组静态资源，数据库连接或内存缓冲区]
            取得资源，归还资源，归还资源时应加互斥锁
    3.work包，无缓冲通过，保证数据能及时处理，实时交换数据。生产者与消费者模型
    */