golang的一些使用技巧

 

1.枚举的实现

const (
   freeTime = 5
   betTime  = 9
   openTime = 7
)

比如 定义字节大小的枚举

const(

 b = 1<<(10*iota) //1

 kb                       //1024

 mb                      //1024*1024

 gb                       //1024*1024*1024

)

 

2.继承

type father struct{
    ID int
    name string
}

var son struct{
    father//继承父类 
    tuiDuan string//腿短特性

}

son.ID
son.name
son.tuiDuan

 

3.如何将一个固定数组转换成切片. 

 var arry [32]byte

func changeToSlice(btSlice []byte){

}

如果直接将变量arry作为参数传入 changeToSlice(arry), 则会提示 类型不匹配的情况.

解决方案:

 changeToSlice( arry[:] )

 

4.如何高效插入一个元素

//插入某元素
func CopyInsert(slice interface{}, pos int, value interface{}) interface{} {
   v := reflect.ValueOf(slice)
   v = reflect.Append(v, reflect.ValueOf(value))
   reflect.Copy(v.Slice(pos+1, v.Len()), v.Slice(pos, v.Len()))
   v.Index(pos).Set(reflect.ValueOf(value))
   return v.Interface()
}

使用

var PlayerList []uint64 //玩家列表

PlayerList = CopyInsert(PlayerList, len(PlayerList), userID).([]uint64) //这里请强转为自身类型

 

5.快速实现 基础类型 的数组成员 排序.

以 []byte为例子

import "sort"
type PlayerCards []byte

//Len()
func (s PlayerCards) Len() int {
   return len(s)
}

//Less():由低到高排序
func (s PlayerCards) Less(i, j int) bool {
   return s[i] < s[j]
}

//Swap()
func (s PlayerCards) Swap(i, j int) {
   s[i], s[j] = s[j], s[i] // 相对于c++的写法  这里的数据交换 显得尤为简单.python貌似也可以
}

 

//调用

func SortCards(cards []byte) []byte {
   var localCards PlayerCards = cards// 同 localCards := cards
   sort.Sort(localCards)
   return localCards
}

 

6.如何写一个单例.

 

// 管理类
type PlayerManger struct {
    players sync.Map //据说这个map是线程安全的
//players map[uint64]*Player
}

// 单例实现
var once sync.Once
var manger *PlayerManger = nil
func GetPlayerManger() *PlayerManger {
    once.Do(func() {
         manger = &PlayerManger{} //manger.players = make(map[uint64]*Player)
    })
    return manger
}

7.指针与 非指针的 成员函数调用

func (bc *BlockChain)SendData(data string){ //A
    /// A-Prt
    bc.Block = data
}

func (bc BlockChain)SendDataX(data string){//B
    /// B-Obj
    bc.Block = data
}

看下这两个函数有什么不同. 答案是肯定的,这两个函数是相同的,只是可调用类型不同.

实例一个指针

ptrBlock := &BlockChain{}
ptrBlock.SendData(" 我是指针" ) //此时Block属性 == " 我是指针"
ptrBlock.SendDataX(" XXXX" ) //此时Block属性 == " 我是指针"  无法改变

数据是无法添加到 bc的block数组的当中的,因为很简单. bc不是指针类型. 所以记得给相应的函数 一个 靠谱的对象.

正解: 值传递无法改变成员内部数据,应该使用指针传递.

8  有缓存chanel 和 无缓存chanel的区别:

就一句话: 无缓存chanel 要求chanel的读取  和写入 必须是并发执行. 

有缓存时,一定是先写入,再读取. 无论是读取 还是写入.一旦缓存满了,就会阻塞.  等待另一边拿走数据,或写入新的数据. 如果缓存未满的时候,则不会阻塞.
例子

func readChan(ch chan int){
   <-ch
   fmt.Println("read:")
}

func writeChan(ch chan int){
   ch<-9527
   fmt.Println("write:")
}

func main() {
    //有缓存
    ch1 := make(chan int,1)
    ch1<-4
    d := <-ch1
    fmt.Println("i want to known what it is?", d)
    //无缓存
    ch2 := make(chan int)
    go writeChan(ch2)
    go readChan(ch2)

    //阻塞用的  也称名目张胆设置关卡
    select {
        default:
    }
}

//持续更新..