Speed up your development process with shortcuts that free you from rewriting routine code, such as functions, variables, structs, etc., see the available snippets:
Here are some examples of using code snippets. You can see the rest of the options below, in this README.
When writing gomain in a file and selecting it for autocomplete it will generate the basic code of a file, for example, start by writing gomain, or just go and you will see the full snippet options:
package main
func main() {
}
Here, by typing goinit we create the init() function that starts before all the functions in the .go file, let's see:
func init() {
}Aqui não precisamos definir nenhum parâmetro.
When typing gofile in an empty file it generates the basic code of a .go file, with name pre-selected for change:
package name
func init() {
}
func main() {
}gofile generates a code that is a little more complete than gomain, also providing us with goinit
When writing gotestfile it will return us a code for a file that contains the import of testing and creation of the package with the initial test function, keeping the word Test for go to recognize it as a test function, the first and only attribute to be defined is the remaining name of the function after Test, remembering that the second word after Test also starts with capital letter example:
package name
import "testing"
func TestNameFunction(t *testing.T) {
}
When writing gofunc it will return us a function with autocompletes in the function name, parameter and return type, just switch with the TAB key after entering one by one, let's see what gofunc generates us:
//gofunc
func name(params type) returnType {
return params
}Remembering that, initially name is the first attribute to be inserted, from a TAB and will jump to the params, being able to insert one or more parameters separated by a comma, from another TAB and it will be in type which is the type of params in the last TAB it will define the return type returnType, do the test.
It generates a test function with the default parameters, see:
func TestNameFunction(t *testing.T) {
}
Here you have the option of creating an empty function, without parameters and without returns, so when typing gofun it will appear, but in the case of an empty function we will use the command gofuncempty which gives us will generate:
func name() {
}Always remember that name has already been selected for name change.
A function that can receive an error and handle it, just start typing gofuncerr and we will have the following result:
func name(params) (returnType, error) {
}With the same modus operandi as other snippets that have more than one value to be changed, this function also follows these patterns and can be switched using TAB when declaring a value and going to the next.
Typing gofunchttp will generate a basic http function like:
func FunctionName(w http.ResponseWriter, r *http.Request) {
}Crtl+S auto-imports the packages that will be used but have not yet been imported.
Here, when typing gostruct you will create a model of a struct, let's see:
type name struct {
varname type
}Starting by defining name with a TAB we can define varname and with another TAB we define the type
Here, when we type gointerface it will give us a snippet of an interface:
type name interface {
}Leaving the name pre-selected for change.
Here, when we type gointer.. it will show us the snippet we are looking for gointerfacegeneric, when selecting it, it will generate the following code:
func name(nameinterface interface{}) {
}As the first pre-selected attribute for renaming, name and with a TAB we also define nameinterface
Returns a function with the clause go to become a goroutine:
go func(params){
}Creates an anonymous goroutine:
go func(){
}()A structure very similar to a switch in decision making, but focused on use with competition, just use our goselect snippet to create a basic structure:
select {
case obj := <-channel1:
fmt.Println("a")
case obj := <-channel2:
fmt.Println("b")
}Creates a declaration of a map variable with key type and value type, in this case it is preselected for changing the varname, keytype and valuetype:
var varname map[keytype]valuetypeWith gomapvalues you will create a map by inference, already being able to assign values, let's see the code generated when using the snippet:
mapname := map[keytype]valuetype{
"key1" : "Value1",
"key2" : "Value1",
}Following the same pattern in order, mapname is the first pre-selected, when navigating with TAB you go to keytpe -> valuetype -> key1 -> value1 and so on and you can change them effortlessly.
Here, when we type govar and select auto complete, it creates a simple variable, receiving the type by inference, receiving a name and a type, see:
name := valHaving the same feature of being self-selected to change the name and when TAB defining the val.
Here, when typing govar the option govartype will appear, unlike govar, govartype creates a variable with a defined type, let's see:
var name typeHaving the same behavior, where name is pre-selected for change and by giving a TAB you can change the type.
When you start typing gowriteheader, the snippet will appear, select it and it will return the following code:
w.WriteHeader(http.StatusBadRequest)gowriter brings us a complete solution to return a json response to the client, using json.Marshal(obj) to be converted into json for the variable ```varJSON`` `, we also check if anything goes wrong during this, and return an error message, if everything went well, we can return our json at the end of the function.
varJson, err := json.Marshal(objectToConvert)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte("ErrorMessage"))
return
}
w.WriteHeader(http.StatusOK)
w.Write(varJson)Remembering that the variables pre-selected for change are:
- varJson (TAB)
- objectToConvert (TAB)
- ErrorMessage
When you start typing gomarshal and select the snippet, it will generate code to convert a struct or other type into a json with the json.Marshal function, see the example:
var varname *varType
varJSON, err := json.Marshal(*varname)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte("ErrorMessage"))
}Remembering that the variables pre-selected for change are:
- varname (TAB)
- varType (TAB)
- ErrorMessage
When you start typing gounmarshal we generate code that uses json.Unmarshal to "translate" our json object as a body of a request into a struct, or expected variable, example:
var varname *varType
if err = json.Unmarshal(body, &varname); err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write(http_error.ResponseError("ErrorMessage"))
return
}Remembering that the variables pre-selected for change are:
- varname (TAB)
- varType (TAB)
- ErrorMessage
As I use a modular architecture that I have been developing from another project of mine, my packages are my modules, each package contained in /internal, must contain the same files and definitions, I will speak briefly here to exemplify why I treat each route per module and centralize its initialization in the next snippets.
Imagine that we have our /internal directory that is responsible for all our packages, imagine a basic /auth package, we would have these files:
- auth.go -> package auth
- auth_test.go -> package auth
- auth_routes.go -> package auth
All using the same package name, where inside
auth_routes.gowe will start by typinggoroutespackage, before even typing it completely, the suggestion to use it will appear.
When selected, it returns this code:
package auth
import (
"net/http"
"github.com/gorilla/mux"
)
func SetupAuthRoutes(router *mux.Router) {
router.HandleFunc("/auth/signin", Signin).Methods(http.MethodPost)
router.HandleFunc("/auth/signup", Signup).Methods(http.MethodPost)
}Later I will show where the functions come from...
Remembering that the variables pre-selected for change are:
- packageName (TAB)
- FuncName is between Setup{FuncName}Routes
- Note that the same package name you choose will be used in the initial route, in this case as it is auth, the first route is /auth.
This should be pretty clear from the following snippets.
Create a simple route by typing goroute it generates the following code:
router.HandleFunc("/routeName", Function).Methods(http.MethodPost)This allows you to quickly add routes to your previously created route file.
Remembering that the variables pre-selected for change are:
- routeName (TAB)
- Function (TAB)
- MethodHTTP
When you start typing gosetuproutes it will show us a snippet to generate code in an empty file that will bring together all the things we added in the packages for a single initialization, then following the example of the / routes auth let's see what our routes.go file looks like,
remembering that for this I created a directory in the root of the project called /routes which contains our file routes.go, I did this because this file will serve all our packages, so it should be separated in a certain way, to serve the application.
When creating the repository and the.go file, we will see the result of our snippet:
// /routes/routes.go
package routes
// imports automaticos com crtl + s
func SetupAppRoutes() *mux.Router {
// users.SetupUserRoutes(router)
router := mux.NewRouter()
auth.SetupAuthRoutes(router)
return router
}After that, just use this SetupAppRoutes function in main like this:
func main(){
...
router := routes.SetupAppRoutes()
...
}And all your routes will be available
When we type goif and select auto complete, we will see the following simple code snippet:
if var operator val {
}Where our var will be preselected, so that you can change it with the name of any variable or value you want to compare, the operator which can be >, ==, for example, and finally ` ``value``` the value we are using for comparison, all of which can be defined just with the keyboard using TAB to switch from one to another.
When we type gofor it will create a simple for, with variable initialization inside it, let's see:
for var := initial-value; var operator value ; var factor {
}Where var is initially pre-selected to be defined as you wish, for example k:= 0, then when giving a TAB it will choose the initial value of var, all var, will be completed together with the first definition of var, that is, if initially the first var is k, all others var will also be, among this too, when giving a TAB, we must also define the operator to stop for, == for example, then we define the factor which can be ++ -- for example.
Here we join our for with range to retrieve values, when typing goforrange it will generate this code snippet:
for index, obj := range array-or-slice {
}Always remember that these defined "names" can be changed by navigating between them with TAB.
With goerr we can treat the error with log.Fatal(err) in a simple if, or as you wish:
if err != nil {
log.Fatal(err)
}log.Fatal() was used as an example, you could handle this error in different ways.
Here we allow the user to enter data via terminal with goreadinput, let's see the generated code snippet:
fmt.Print("Enter input: ")
var input type
fmt.Scanln(&input)Here you must only change the type, after which you can receive a value that you enter via the terminal.