// 我是谁已经不重要了,重要的是我们可以一起同行! 来吧, 一起go吧!
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
}
type son struct{
father//继承父类
tuiDuan string//腿短特性
}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.ApendBlock
}
func (bc BlockChain)SendData(data string){//B
/// B-Obj
bc.ApendBlock
}看下这两个函数有什么不同. 答案是肯定的,这两个函数是相同的,只是可调用类型不同.
实例一个指针
ptrBlock := &BlockChain{}在没有实例 A, 仅仅实例B的情况下 , 进行调用.
ptrBlock.SendData(" 我是指针" )数据是无法添加到 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:
}
}//持续更新..