Go: criando uma API Rest

Ambiente de desenvolvimento - Apresentação

Olá, me chamo Guilherme Lima.

Audiodescrição: Guilherme se declara um homem de pele clara, com barba e cabelo curto. Usa óculos com armação quadrada e preta e veste uma camiseta amarela. Ao fundo, uma parede com uma iluminação lilás e verde e um quadro à esquerda.

Fico muito feliz que tenha interesse em aprender a linguagem Go, criada pela Google, para resolver problemas complexos com poucas linhas de código.

O que vamos aprender?

Neste curso, preparamos o ambiente de desenvolvimento, exploramos os tipos primitivos e comparamos as diferenças entre Go e outras linguagens de programação, como Python e JavaScript.

Além disso, aprendemos sobre Structs, um conceito essencial no Go, e seguimos boas práticas de programação e as convenções da linguagem. Ao final, desenvolvemos uma API Rest.

Neste curso, não dedicaremos atenção ao banco de dados que será conectado, seja Mongo ou qualquer outro ORM que venhamos a utilizar. Esse aspecto não será o nosso foco principal, pois nossa prioridade estará completamente voltada para o aprendizado da linguagem em si.

Concluiremos essa parte do curso com uma API Rest capaz de exibir recursos, buscar recursos por ID e implementar diversas funcionalidades interessantes.

O foco será na linguagem, e espero que você esteja animado para acompanhar. Estou muito animado por ser o seu instrutor neste curso de Go!

Ambiente de desenvolvimento - Primeiro programa

Iniciamos o estudo de Go com a necessidade de ter o Go instalado no sistema operacional.

Na atividade anterior, fornecemos um passo a passo para a instalação do Go no Windows, Linux e Mac.

Verificaremos se o Go já está instalado no nosso sistema no terminal da nossa máquina. Digitamos go version, pressionamos "Enter", e a versão do Go utilizada será exibida.

go version

go version go1.22.5 darwin/arm64

No caso, é a versão 1.22.5. Fechamos esta janela e continuamos com o conteúdo.

Criaremos um sistema em Go para listar diversas pizzas de uma pizzaria e cadastrar novas opções. Neste primeiro momento, não nos preocupamos com o banco de dados ou com a forma de mensageria a ser utilizada, pois esse não é o foco agora.

Nosso foco será exclusivamente na linguagem Go. Portanto, usaremos bastante código Go para concluir o projeto da pizzaria com sucesso.

Na áre de trabalho da nossa máquina, clicamos com o botão direito e criamos uma nova pasta (opção "New folder") chamada pizzaria. Abrimos o Visual Studio Code e arrastamos a pasta pizzaria para dentro dele. Com a combinação "Ctrl + J", abrimos o terminal e executamos o comando go mod init, que prepara o ambiente de desenvolvimento com Go.

go mod init

Sempre que utilizamos o comando go mod init, inicializamos um ambiente muito similar ao que encontramos em outras linguagens, como o requirements.txt no Python, a gemfile do Hub, ou o package.json do npm no JavaScript.

A ideia é basicamente a mesma. Isso significa que, ao digitarmos o nome do projeto, como pizzaria, e pressionarmos "Enter", o sistema cria um arquivo go.mod, onde são listadas todas as dependências necessárias para o projeto e o módulo que estamos desenvolvendo.

go mod init pizzaria

go: creating new go.mod: module pizzaria

Observando do lado esquerdo, temos o arquivo go.mod:

module pizzaria

go 1.22.5

É importante que tenhamos em mente dois pontos essenciais sobre esse processo.

Primeiro, não é recomendado gerenciar ou editar o arquivo go.mod manualmente. Existem comandos específicos no Go para realizar essas operações de forma adequada. Quando precisamos instalar uma nova dependência, utilizamos um comando do Go para isso, e também há comandos para limpar dependências que não estão sendo usadas.

Esses comandos serão abordados ao longo do curso. Portanto, é essencial que iniciemos o projeto com o go.mod. No passado, era comum configurar o GoPath e o caminho do GoRoute, mas hoje em dia utilizamos esse método mais moderno e prático.

Criando um programa básico em Go

O próximo passo, agora que o módulo está criado, é digitar um programa básico em Go. Para isso, criamos um novo arquivo, utilizando o atalho "Ctrl + N", e o nomeamos como main.go.

Atenção: ao utilizar o nome main.go, indicamos que esse será o arquivo principal da aplicação.

Em projetos maiores, esse arquivo geralmente fica dentro de uma pasta chamada cmd, onde encontramos o main.go. No nosso caso, como estamos criando o projeto do zero, temos apenas esse arquivo.

O main.go serve como ponto de entrada do programa, ou seja, é a partir dele que nosso código será executado, mesmo que outros arquivos Go estejam envolvidos no projeto.

Há um ponto crucial a ser destacado: todo programa em Go começa com uma função main, que está no pacote main. Portanto, a primeira coisa que definimos em um código Go é o pacote. Digitamos package main para indicar que este é o arquivo que inicia o programa.

main.go

package main

O package main significa que, através deste arquivo, nosso programa é inicializado. Criaremos uma função main dentro do pacote main, que é onde nosso programa será executado. Para definir uma função em Go, usamos func main. Assim como em JavaScript usamos function e em Python usamos def, no Go utilizamos func.

Digitamos func main seguido de parênteses e chaves. Tudo que estiver relacionado à função main deve ser colocado dentro dessas chaves.

package main

func main() {

}

Observe que usamos chaves, semelhante ao estilo de linguagem C, Java e JavaScript. Isso mostra que o Go segue um estilo semelhante ao do C.

Exibindo "Hello, World"

Vamos criar o "Hello, World". Para exibir o "Hello, World" no Go, utilizamos o pacote fmt, que é responsável por funções como exibir mensagens no terminal e receber informações.

Para exibir a mensagem, usamos a função fmt.Println(). Observe que o import "fmt" aparece automaticamente acima da função. Portanto, dentro da função main, chamamos fmt.Println("Hello, World!"), onde "Hello, World!" é a mensagem que será exibida no terminal.

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Observe que usamos aspas duplas para strings no Go; aspas simples são raramente usadas.

Compilando e executando o programa

Para executar um programa Go, precisamos compilar o código e, em seguida, executá-lo. O Go é uma linguagem compilada, não interpretada. Isso significa que o código Go precisa ser compilado em um arquivo executável antes de ser executado.

Existem duas maneiras principais de visualizar a execução do código Go:

• Usando o comando go run .: Para testar o programa, você pode usar go run main.go, e isso exibirá a mensagem "Hello, World!" no terminal.
• Usando o comando go build .: Compilamos o código com o comando go build. Isso cria um arquivo executável (com o mesmo nome do diretório, como pizzaria se você estiver na pasta pizzaria). Em seguida, executamos o arquivo gerado para ver a saída.

O ponto após o go run e go build já indica o arquivo main.go.

Vamos entender mais um pouco sobre esses comandos:

Para a demonstração em um ambiente de desenvolvimento, usamos o comando go run main.go para compilar e executar diretamente o arquivo main.go. O comando go run é conveniente para testes rápidos e é recomendado quando o objetivo é verificar a execução do código.

Se desejamos criar e distribuir um arquivo binário, similar à compilação em Java, podemos usar o comando go build .. Esse comando compila o código e gera um arquivo executável chamado pizzaria, mas não exibe mensagens de saída no terminal.

Após a execução do comando, será criado um arquivo binário na pasta do projeto. Verificaremos o arquivo gerado. Esse arquivo executável pode ser executado diretamente; ao dar um duplo clique nele, a mensagem "Hello, World!" será exibida, indicando que o processo foi concluído com sucesso.

Portanto, temos duas formas principais de executar o código Go:

• Usar go run . para compilar e executar o código diretamente, ideal para testes rápidos.
• Usar go build . para gerar um arquivo binário que pode ser distribuído e executado separadamente.

Durante o curso, é recomendável usar o comando go run para testar o código, já que estamos em um ambiente de desenvolvimento e não precisamos distribuir o binário executável.

Por exemplo, se alterarmos a mensagem de "Hello, World!" para "Pizzaria", atualizamos o programa e utilizamos go run main.go para ver a mensagem "Pizzaria" exibida no terminal.

package main

import "fmt"

func main() {
    fmt.Println("Pizzaria")
}

Executamos o comando no terminal:

go run main.go

Obtemos:

Pizzaria

Próximo passo

O próximo desafio será aprender a criar e trabalhar com variáveis em Go, que apresenta algumas diferenças em relação a outras linguagens. Até mais!

Ambiente de desenvolvimento - Variáveis e convenções

A linguagem Go oferece diferentes maneiras de criar variáveis e definir o código de forma natural e conveniente. Temos o nome "Pizzaria" e desejamos atribuí-lo a uma variável, podemos fazer isso de maneira direta. Vamos usar a API chamada "Pizzaria Go" para esse fim.

Variáveis em Go

Em outras linguagens de programação, como Python, normalmente definimos uma variável para a Pizzaria como nomePizzaria e atribuímos o valor "Pizzaria Go" a ela.

main.go

package main

import "fmt"

func main() {
     var nomePizzaria = "Pizzaria Go"
    fmt.Println("Pizzaria")
}

No entanto, no Go, isso não funciona da mesma forma. O Go não reconhece diretamente essa expressão e retorna um erro, dizendo: "Não foi possível identificar o nomePizzaria".

Para criar uma variável do tipo string em Go, usamos a palavra reservada var. Digitamos var nome string. Ao passar o mouse sobre a variável nomePizzaria, podemos ver a mensagem "nomePizzaria foi declarado, mas não foi usado".

nomePizzaria declared and not used compiler(UnuseVar)

var nomePizzaria string

Repare que o Go adicionou automaticamente a palavra string ao nosso código.

package main

import "fmt"

func main() {
     var nomePizzaria string = "Pizzaria Go"
    fmt.Println("Pizzaria")
}

No entanto, mesmo assim, o erro persiste: "nomePizzaria declarado e não usado". Em Go, é necessário utilizar todas as variáveis que declaramos. Se não usarmos uma variável, o programa não compilará corretamente.

Vamos salvar e tentar executar o código. Abrimos o terminal e executamos seguinte código:

go run main.go

./main.go:6.6: nomePizzaria declared and not used

O erro retornado será: "na linha 6, nomePizzaria declarado e não usado". Portanto, no Go, não podemos deixar de usar as variáveis que criamos. Removemos a declaração do Println() que está com a string Pizzaria e inserimos nomePizzaria.

package main

import "fmt"

func main() {
     var nomePizzaria string = "Pizzaria Go"
    fmt.Println(nomePizzaria)
}

Após salvar as alterações, retornamos ao terminal e executamos o código novamente com go run.

go run main.go

O resultado exibido será "Pizzaria Go".

Além da forma tradicional de declarar variáveis em Go, existe a anotação chamada short assign statement. Nesta abordagem, não usamos a palavra var nem especificamos o tipo da variável (string, no caso). Em vez disso, utilizamos o sinal := para permitir que o Go insira o tipo da variável automaticamente. Digitamos nomePizzaria := "Pizzaria Go".

package main

import "fmt"

func main() {
     nomePizzaria := "Pizzaria Go"
    fmt.Println(nomePizzaria)
}

Se passarmos o mouse sobre a variável, veremos a anotação var nomePizzaria string, indicando que o Go identificou o tipo como string. Se, por exemplo, atribuirmos o valor 42 à variável (nomePizzaria := 42), a anotação mudará para int. Da mesma forma, se atribuímos o valor 42.5, o tipo identificado será float64.

No Go, há várias formas de definir variáveis. A forma que estamos mostrando, o short assignment, é bastante utilizada. Podemos optar por usar var, seguido pelo nome da variável, o tipo e o valor a ser atribuído.

Outra opção é usar o short assignment com :=, onde apenas o nome da variável e o valor são especificados, permitindo que o Go infira automaticamente o tipo. Assim, temos diferentes maneiras de declarar variáveis, adaptando-se às necessidades do código.

Além disso, podemos declarar múltiplas variáveis simultaneamente. Para definir o nome da Pizzaria, o Instagram e o telefone, podemos digitar instagram, telefone := "@pizzaria_go", 11951.

package main

import "fmt"

func main() {
     nomePizzaria := "Pizzaria Go"
     instagram, telefone := "@pizzaria_go", 11951
    fmt.Println(nomePizzaria)
}

Se o Go exibir um erro como "Instagram declarado e não usado", significa que a variável não foi utilizada após a declaração.

instagram declared and not used ci piler(UnusedVar)

Para resolver isso, podemos incluir fmt.Println(nomePizzaria, instagram, telefone) para exibir os valores.

package main

import "fmt"

func main() {
     nomePizzaria := "Pizzaria Go"
     instagram, telefone := "@pizzaria_go", 11951
    fmt.Println(nomePizzaria, instagram, telefone)
}

Dessa forma, o código funcionará corretamente. Note que, em uma única linha e instrução, conseguimos criar várias variáveis de tipos diferentes: telefone do tipo int e instagram do tipo string.

Quando executamos o programa com go run main.go, ele funciona normalmente:

Retorno no terminal:

Pizzaria Go @pizzaria_go 11951

Qual é a melhor forma de declarar?

A escolha entre usar o short assignment ou a declaração tradicional com var depende do contexto do seu trabalho.

Se precisamos ter controle explícito sobre o tipo da variável, como quando é essencial garantir que ela seja um int ou uma string, é melhor usarmos a forma tradicional: var nomePizzaria string.

Por outro lado, se não é necessário definir o tipo explicitamente e podemos confiar na inferência automática do Go, como feito com instagram e telefone, o short assignment (:=) é uma opção mais concisa e prática.

Observamos também que o pacote fmt segue a mesma regra das variáveis: se um pacote ou variável é importado e não utilizado, o Go sinaliza um aviso, dizendo "o pacote fmt foi importado e não foi usado".

Isso ocorre, por exemplo, se removemos a linha que usa Println() e comentamos as linhas de código, resultando na remoção automática do import do pacote ao salvarmos as alterações.

package main

func main() {
     // var nomePizzaria string = "Pizzaria Go"
     // instagram, telefone := "@pizzaria_go", 11951
    // fmt.Println(nomePizzaria, instagram, telefone)
}

Quando retornamos o código ao estado original, descomentando as linhas (com duas barras //, como em JavaScript), o Go restaura automaticamente o import do pacote.

package main

import "fmt"

func main() {
     // var nomePizzaria string = "Pizzaria Go"
     // instagram, telefone := "@pizzaria_go", 11951
    // fmt.Println(nomePizzaria, instagram, telefone)
}

Assim, o Go mantém o código limpo e só inclui importações que são efetivamente utilizadas.

Como a linguagem Go se comporta

O Go adota essas práticas de gerenciamento de variáveis e pacotes para garantir um desempenho otimizado. Desenvolvido pela Google no final de 2007 e lançado ao público em 2009, o Go foi criado com foco em performance.

Muitos programas na época eram escritos em C, e o Go visava melhorar a eficiência e a entrega de performance ao impor regras como a obrigatoriedade de uso de variáveis declaradas e pacotes importados. Essas regras ajudam a manter o código limpo e eficiente, contribuindo para uma execução mais rápida e um gerenciamento de recursos mais eficaz.

Próximo passo

O próximo passo é descobrir como começamos a construir nossa API. Vamos explorar isso a seguir!

Sobre o curso Go: criando uma API Rest

O curso Go: criando uma API Rest possui 93 minutos de vídeos, em um total de 44 atividades. Gostou? Conheça nossos outros cursos de Go em Back-end, ou leia nossos artigos de Back-end.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Ambiente de desenvolvimento
• Structs
• API Rest
• Recursos e novas rotas
• Trabalhando com recursos