首页  思维导图  详情

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) }