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 GoLang em Programação, ou leia nossos artigos de Programação.

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