🦁

VSCodeのGo言語用スニペットが便利！

2023/06/10に公開

VS Code

tech

VSCodeにGoogleのGoチームが開発しているGoの公式拡張をインストールすると、便利なスニペットが使えるようになるので紹介します。最近気づきました。💦

使い方

拡張子が.goのファイルの中で、以下の一覧に記載されているプレフィックスを入力してください。
IntelliSenseが表示されてスニペットが候補として出てくるので、選択してEnterキーで確定します。

スニペットが入力されると$1の箇所にカーソルが置かれます。
Tabキーで$2, $3, ... と移動できます。

スニペットの一覧

single import

プレフィックス: im

import "${1:package}"

multiple imports

プレフィックス: ims

import (
	"${1:package}"
)

single constant

プレフィックス: co

const ${1:name} = ${2:value}

multiple constants

プレフィックス: cos

const (
	${1:name} = ${2:value}
)

type function declaration

プレフィックス: tyf

type ${1:name} func($3) $4

type interface declaration

プレフィックス: tyi

type ${1:name} interface {
	$0
}

type struct declaration

プレフィックス: tys

type ${1:name} struct {
	$0
}

package main and main function

プレフィックス: pkgm

package main

func main() {
	$0
}

function declaration

プレフィックス: func

func $1($2) $3 {
	$0
}

single variable

プレフィックス: var

var ${1:name} ${2:type}

multiple variables

プレフィックス: vars

var (
	${1:name} ${2:type}
)

switch statement

プレフィックス: switch

switch ${1:expression} {
case ${2:condition}:
	$0
}

select statement

プレフィックス: sel

select {
case ${1:condition}:
	$0
}

case clause

プレフィックス: cs

case ${1:condition}:$0

for statement

プレフィックス: for

for ${1:i} := ${2:0}; $1 < ${3:count}; $1${4:++} {
	$0
}

for range statement

プレフィックス: forr

for ${1:_, }${2:v} := range ${3:v} {
	$0
}

channel declaration

プレフィックス: ch

chan ${1:type}

map declaration

プレフィックス: map

map[${1:type}]${2:type}

empty interface

プレフィックス: in

interface{}

if statement

プレフィックス: if

if ${1:condition} {
	$0
}

else branch

プレフィックス: el

else {
	$0
}

if else statement

プレフィックス: ie

if ${1:condition} {
	$2
} else {
	$0
}

if err != nil

プレフィックス: iferr

if err != nil {
	${1:return ${2:nil, }${3:err}}
}

fmt.Println

プレフィックス: fp

fmt.Println("$1")

fmt.Printf

プレフィックス: ff

fmt.Printf("$1", ${2:var})

log.Println

プレフィックス: lp

log.Println("$1")

log.Printf

プレフィックス: lf

log.Printf("$1", ${2:var})

log variable content

プレフィックス: lv

log.Printf("${1:var}: %#+v\\\\n", ${1:var})

t.Log

プレフィックス: tl

t.Log("$1")

t.Logf

プレフィックス: tlf

t.Logf("$1", ${2:var})

t.Logf variable content

プレフィックス: tlv

t.Logf("${1:var}: %#+v\\\\n", ${1:var})

make(...)

プレフィックス: make

make(${1:type}, ${2:0})

new(...)

プレフィックス: new

new(${1:type})

panic(...)

プレフィックス: pn

panic("$0")

http ResponseWriter *Request

プレフィックス: wr

${1:w} http.ResponseWriter, ${2:r} *http.Request

http.HandleFunc

プレフィックス: hf

${1:http}.HandleFunc("${2:/}", ${3:handler})

http handler declaration

プレフィックス: hand

func $1(${2:w} http.ResponseWriter, ${3:r} *http.Request) {
	$0
}

http.Redirect

プレフィックス: rd

http.Redirect(${1:w}, ${2:r}, "${3:/}", ${4:http.StatusFound})

http.Error

プレフィックス: herr

http.Error(${1:w}, ${2:err}.Error(), ${3:http.StatusInternalServerError})

http.ListenAndServe

プレフィックス: las

http.ListenAndServe("${1::8080}", ${2:nil})

http.Serve

プレフィックス: sv

http.Serve("${1::8080}", ${2:nil})

goroutine anonymous function

プレフィックス: go

go func($1) {
	$0
}($2)

goroutine function

プレフィックス: gf

go ${1:func}($0)

defer statement

プレフィックス: df

defer ${1:func}($0)

test function

プレフィックス: tf

func Test$1(t *testing.T) {
	$0
}

test main

プレフィックス: tm

func TestMain(m *testing.M) {
	$1

	os.Exit(m.Run())
}

benchmark function

プレフィックス: bf

func Benchmark$1(b *testing.B) {
	for ${2:i} := 0; ${2:i} < b.N; ${2:i}++ {
		$0
	}
}

example function

プレフィックス: ef

func Example$1() {
	$2
	//Output:
	$3
}

table driven test

プレフィックス: tdt

func Test$1(t *testing.T) {
	testCases := []struct {
		desc	string
		$2
	}{
		{
			desc: "$3",
			$4
		},
	}
	for _, tC := range testCases {
		t.Run(tC.desc, func(t *testing.T) {
			$0
		})
	}
}

init function

プレフィックス: finit

func init() {
	$1
}

main function

プレフィックス: fmain

func main() {
	$1
}

method declaration

プレフィックス: meth

func (${1:receiver} ${2:type}) ${3:method}($4) $5 {
	$0
}

hello world web app

プレフィックス: helloweb

package main

import (
	"fmt"
	"net/http"
	"time"
)

func greet(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello World! %s", time.Now())
}

func main() {
	http.HandleFunc("/", greet)
	http.ListenAndServe(":8080", nil)
}

sort implementation

プレフィックス: sort

type ${1:SortBy} []${2:Type}

func (a $1) Len() int           { return len(a) }
func (a $1) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a $1) Less(i, j int) bool { ${3:return a[i] < a[j]} }

使い方