首页  思维导图  详情

Goland Live Template

2022-09-23 18:04:40   4  举报





AI智能生成

Goland快捷指令代码

golang

Goland

Live Template

作者其他创作

大纲/内容

Live Template是什么

代码里输入指令回车后输出模板，加快写代码的效率

如何使用Live Template

Preferences/Editor/Live Templates

第4步

常用模板

如何导入

单元测试

goconvy和gomonkey

goconvey

myimport

goconvey导包

. "github.com/smartystreets/goconvey/convey"

test

单元测试

func Test_$NAME$(t *testing.T) {
Convey("$NAME$", t, func() {
Convey("$NAME$ test1", func() {
$START$
})
})
}

convey

Convey("$START$", func() {
$END$
})

断言

So($ERR$, ShouldEqual, $VALUE$)
$END$

gomonkey

patch

打桩初始化

patches := gomonkey.NewPatches()
$START$
defer patches.Reset()

applyfunc

函数打桩

patches = patches.ApplyFunc($FUNCATION$, func($PARAM$) $RETURN$ {
$MAINBODY$
return $RETURNVALUE$
})
//第一个参数是方法（不是string类型），第二个是桩函数
//patches = patches.ApplyFunc(Add, func(a, b int) int {
// return a-b
//})

applyfuncreturn

函数打桩

patches = patches.ApplyFuncReturn($FUNC$, $RETURN$)
//第一个是函数名（不是string类型），第二个是函数返回值
//patches = patches.ApplyFuncReturn(Add, 9999)

applymethodfunc

public方法打桩

patches = patches.ApplyMethodFunc(u, "$METHOD$", func ($PARAM$) $RETURN${
$MAINBODY$
return $RETURNVALUE$
})
//u := PublicMethodStruct{}
//第一个参数是对象，第二个参数是方法名string类型，第三个是桩函数
//patches = patches.ApplyMethodFunc(u, "Hello", func () string{
// return "haha"
//})

applyprivatemethodptr

private指针类型方法打桩

patches = patches.ApplyPrivateMethod(reflect.TypeOf($STRUCT$), "$FUNC$", func(this *$STRUCTTYPE$ $PARAM$) $RETURN$ {
$MAINBODY$
return $RETURNVALUE$
})
//指针类型ApplyPrivateMethod的第一个参数u需要取地址，第二个是原函数方法名，第三个参数是一个桩函数
//桩函数的第一个入参是该结构体指针，如果原函数还有其他入参，也需要作为桩函数的入参，桩函数的返回值就是原函数的返回值
//patches := gomonkey.ApplyPrivateMethod(reflect.TypeOf(&u), "add", func(this *PrivateMethodStruct) {
// this.time -= 10
//})

applyprivatemethodval

private值类型方法打桩

patches = patches.ApplyPrivateMethod(reflect.TypeOf($STRUCT$), "$FUNC$", func(this $STRUCTTYPE$ $PARAM$) $RETURN$ {
$MAINBODY$
return $RETURNVAL$
})
//值类型ApplyPrivateMethod的第一个参数u不需要取地址，第二个是原函数方法名，第三个参数是一个桩函数
//桩函数的第一个入参是该结构体（不是结构体指针），如果原函数还有其他入参，也需要作为桩函数的入参，桩函数的返回值就是原函数的返回值
//u := PrivateMethodStruct{}
//patches := gomonkey.ApplyPrivateMethod(reflect.TypeOf(u), "hello", func(_ PrivateMethodStruct) string {
// return "null"
//})

golang

go携程

go func() {
    defer func() {
        if p := recover(); p != nil {
            logger.LogErrorf("$FIRST$ panic=%v, stack=%v", p, string(debug.Stack()))
            $SECOND$
        }
    }()
    $THIRD$
}()

panic

捕获panic

defer func() {
    if p := recover(); p != nil {
        logger.LogErrorf("$START$ panic=%v, stack=%v", p, string(debug.Stack()))
        $END$
    }
}()

Algorithm

unionfind

路径压缩并查集

type PathCompressionUnionFind struct {
parents []int
size []int
}

func NewPathCompressionUnionFind(len int) *PathCompressionUnionFind {
parents := make([]int, len)
size := make([]int, len)
for i := range parents {
  parents[i] = i
  size[i] = 1
}

return &PathCompressionUnionFind{
  parents: parents,
  size:    size,
}
}

func (t *PathCompressionUnionFind) Union(p, q int) {
pRoot := t.Find(p)
qRoot := t.Find(q)
if pRoot == qRoot {
  return
}
t.parents[qRoot] = t.parents[pRoot]
t.size[pRoot] += t.size[qRoot]
}

func (t *PathCompressionUnionFind) Find(p int) int {
for t.parents[p] != p {
  t.parents[p] = t.parents[t.parents[p]]
  p = t.parents[p]
}
return p
}

func (t *PathCompressionUnionFind) GetSize(p int) int {
if p < 0 || p >= len(t.parents) {
  return 0
}
return t.size[t.Find(p)]
}

heap

堆

type $STRUCT$ struct{
weight int
$FIELDS$
}
type compare func(a, b interface{}) bool
type heapHandler struct{
arr []*$STRUCT$
cmp compare
}
func (h heapHandler) Len() int            {return len(h.arr)}
func (h heapHandler) Swap(i, j int)       { h.arr[i], h.arr[j] = h.arr[j], h.arr[i]}
func (h *heapHandler) Push(x interface{}) { h.arr = append(h.arr, x.(*$STRUCT$))}
func (h heapHandler) Less(i, j int) bool  {return h.cmp(h.arr[i], h.arr[j])}
func (h *heapHandler) Pop() interface{} {
old := h.arr
n := h.Len()
x := old[n-1]
h.arr = old[:n-1]
return x
}
type MyHeap struct{h *heapHandler}
func NewMyHeap(arr []*$STRUCT$, cmp compare) *MyHeap {
res := &MyHeap{&heapHandler{cmp: cmp}}
if len(arr) == 0 {return res}
res.h.arr = arr
heap.Init(res.h)
return res
}
func (m *MyHeap) Push(x interface{}) {heap.Push(m.h, x)}
func (m *MyHeap) Peek() interface{}  {return m.h.arr[0]}
func (m *MyHeap) Pop() interface{}   {return heap.Pop(m.h)}
func (m *MyHeap) Len() int           {return m.h.Len()}

binarysearchint

二分查找

func BinarySearchInt(arr []int, target int) int {
left := 0
right := len(arr) - 1
for left <= right {
  mid := (left + right) >> 1
  if arr[mid] == target {
   return mid
  }
  if arr[mid] > target {
   right = mid - 1
  } else {
   left = mid + 1
  }
}
return -(left + 1)
}