254 lines
3.5 KiB
Text
254 lines
3.5 KiB
Text
# shorthand variable declaration
|
|
snippet v
|
|
${1} := ${2}
|
|
# variable initialization
|
|
snippet vr
|
|
var ${1:t} ${0:string}
|
|
# variable declaration
|
|
snippet var
|
|
var ${1} ${2} = ${3}
|
|
# variables declaration
|
|
snippet vars
|
|
var (
|
|
${1} ${2} = ${3}
|
|
)
|
|
# append
|
|
snippet ap
|
|
append(${1:slice}, ${0:value})
|
|
# bool
|
|
snippet bl
|
|
bool
|
|
# byte
|
|
snippet bt
|
|
byte
|
|
# break
|
|
snippet br
|
|
break
|
|
# channel
|
|
snippet ch
|
|
chan ${0:int}
|
|
# case
|
|
snippet cs
|
|
case ${1:value}:
|
|
${0:${VISUAL}}
|
|
# const
|
|
snippet c
|
|
const ${1:NAME} = ${0:0}
|
|
# constants with iota
|
|
snippet co
|
|
const (
|
|
${1:NAME1} = iota
|
|
${0:NAME2}
|
|
)
|
|
# continue
|
|
snippet cn
|
|
continue
|
|
# defer
|
|
snippet df
|
|
defer ${0:func}()
|
|
# defer recover
|
|
snippet dfr
|
|
defer func() {
|
|
if err := recover(); err != nil {
|
|
${0:${VISUAL}}
|
|
}
|
|
}()
|
|
# int
|
|
snippet i
|
|
int
|
|
# import
|
|
snippet im
|
|
import (
|
|
"${1:package}"
|
|
)
|
|
# interface
|
|
snippet in
|
|
interface{}
|
|
# full interface snippet
|
|
snippet inf
|
|
interface ${1:name} {
|
|
${2:/* methods */}
|
|
}
|
|
# if condition
|
|
snippet if
|
|
if ${1:/* condition */} {
|
|
${2:${VISUAL}}
|
|
}
|
|
snippet ife
|
|
if ${1:/* condition */} {
|
|
${2:${VISUAL}}
|
|
} else {
|
|
${0}
|
|
}
|
|
# else snippet
|
|
snippet el
|
|
else {
|
|
${0:${VISUAL}}
|
|
}
|
|
# error snippet
|
|
snippet ir
|
|
if err != nil {
|
|
return err
|
|
}
|
|
${0}
|
|
# false
|
|
snippet f
|
|
false
|
|
# fallthrough
|
|
snippet ft
|
|
fallthrough
|
|
# float
|
|
snippet fl
|
|
float32
|
|
# float32
|
|
snippet f3
|
|
float32
|
|
# float64
|
|
snippet f6
|
|
float64
|
|
# for int loop
|
|
snippet for
|
|
for ${1}{
|
|
${0:${VISUAL}}
|
|
}
|
|
# for int loop
|
|
snippet fori
|
|
for ${2:i} := 0; $2 < ${1:count}; $2${3:++} {
|
|
${0:${VISUAL}}
|
|
}
|
|
# for range loop
|
|
snippet forr
|
|
for ${1:e} := range ${2:collection} {
|
|
${0:${VISUAL}}
|
|
}
|
|
# function simple
|
|
snippet fun
|
|
func ${1:funcName}(${2}) ${3:error} {
|
|
${4}
|
|
}
|
|
${0}
|
|
# function on receiver
|
|
snippet fum
|
|
func (${1:receiver} ${2:type}) ${3:funcName}(${4}) ${5:error} {
|
|
${6}
|
|
}
|
|
${0}
|
|
# log printf
|
|
snippet lf
|
|
log.Printf("%${1:s}", ${2:var})
|
|
# log printf
|
|
snippet lp
|
|
log.Println("${1}")
|
|
# make
|
|
snippet mk
|
|
make(${1:[]string}, ${0:0})
|
|
# map
|
|
snippet mp
|
|
map[${1:string}]${0:int}
|
|
# main()
|
|
snippet main
|
|
func main() {
|
|
${1}
|
|
}
|
|
${0}
|
|
# new
|
|
snippet nw
|
|
new(${0:type})
|
|
# package
|
|
snippet pa
|
|
package ${1:main}
|
|
# panic
|
|
snippet pn
|
|
panic("${0:msg}")
|
|
# print
|
|
snippet pr
|
|
fmt.Printf("%${1:s}\n", ${2:var})
|
|
# println
|
|
snippet pl
|
|
fmt.Println("${1:s}")
|
|
# range
|
|
snippet rn
|
|
range ${0}
|
|
# return
|
|
snippet rt
|
|
return ${0}
|
|
# result
|
|
snippet rs
|
|
result
|
|
# select
|
|
snippet sl
|
|
select {
|
|
case ${1:v1} := <-${2:chan1}
|
|
${3}
|
|
default:
|
|
${0}
|
|
}
|
|
# string
|
|
snippet sr
|
|
string
|
|
# struct
|
|
snippet st
|
|
struct ${1:name} {
|
|
${2:/* data */}
|
|
}
|
|
${0}
|
|
# switch
|
|
snippet sw
|
|
switch ${1:var} {
|
|
case ${2:value1}:
|
|
${3}
|
|
case ${4:value2}:
|
|
${5}
|
|
default:
|
|
${0}
|
|
}
|
|
snippet sp
|
|
fmt.Sprintf("%${1:s}", ${2:var})
|
|
# true
|
|
snippet t
|
|
true
|
|
# goroutine named function
|
|
snippet g
|
|
go ${1:funcName}(${0})
|
|
# goroutine anonymous function
|
|
snippet ga
|
|
go func(${1} ${2:type}) {
|
|
${3:/* code */}
|
|
}(${0})
|
|
snippet test test function
|
|
func Test${1:name}(t *testing.T) {
|
|
${0:${VISUAL}}
|
|
}
|
|
snippet bench benchmark function
|
|
func Benchmark${1:name}(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
${2}
|
|
}
|
|
}
|
|
${0}
|
|
# composite literals
|
|
snippet cl
|
|
type ${1:name} struct {
|
|
${2:attrName} ${3:attrType}
|
|
}
|
|
# if key in a map
|
|
snippet om
|
|
if ${1:value}, ok := ${2:map}[${3:key}]; ok == true {
|
|
${4:/* code */}
|
|
}
|
|
|
|
# Grouped globals with anonymous struct
|
|
snippet gg
|
|
var ${1:var} = struct{
|
|
${2:name} ${3:type}
|
|
}{
|
|
$2: ${4:value},
|
|
}
|
|
|
|
# Marshalable json alias
|
|
snippet ja
|
|
type ${1:parentType}Alias $1
|
|
|
|
func (p *$1) MarshalJSON() ([]byte, error) {
|
|
return json.Marshal(&struct{ *$1Alias }{(*$1Alias)(p)})
|
|
}
|