PRIMEIROS PASSOS EM GO

INTRODUÇÃO A LINGUAGEM DE
PROGRAMAÇÃO

Kage Jinsei
 Credits / Créditos

Gopher Images from:

https://github.com/ashleymcnamara/gophers

Ashley Willis

__________________________

Imagens do Gopher:
https://github.com/ashleymcnamara/gophers

Ashley Willis
__________________________

Inspiration and Ideas:

W3Schools: https://www.w3schools.com/
OpenAI: https://chat.openai.com/

__________________________

Inspiração e Ideias:

W3Schools: https://www.w3schools.com/
OpenAI: https://chat.openai.com/
Sumário
1. Introdução a Go....................................................................................................5
2. Configurando ambiente........................................................................................7
3. Estrutura básica do programa............................................................................20
4. Módulos..............................................................................................................22
5. Olá, Mundo!........................................................................................................25
6. Comentários.......................................................................................................28
7. Tipos, valores e variáveis...................................................................................30
8. Constantes......................................................................................................... 34
9. Outputs...............................................................................................................38
10. Verbos de formatação......................................................................................40
11. Tipos de dados................................................................................................. 43
12. Arrays............................................................................................................... 53
13. Slices................................................................................................................57
14. Operadores.......................................................................................................65
15. Estruturas condicionais....................................................................................71
16. Switch...............................................................................................................78
17. Loops................................................................................................................82
18. Functions..........................................................................................................89
19. Structs............................................................................................................ 101
20. Maps...............................................................................................................104
 5

1. Introdução a Go

Go, também conhecida como Golang, é uma linguagem de

programação de código aberto desenvolvida pelo Google. Foi
projetada para ser eficiente, concisa, simples e fácil de ler. O
projeto inicial da linguagem de programação Go foi iniciado em
setembro de 2007 por três engenheiros renomados: Robert
Griesemer, Rob Pike e Ken Thompson, que trabalhavam no
Google. Eles colaboraram para criar uma linguagem que atendesse
às necessidades específicas de desenvolvimento de software no
ambiente do Google, enfocando eficiência, concisão e legibilidade
do código. A primeira versão estável foi lançada em 2012. Algumas
características notáveis da linguagem Go incluem:

Concorrência e Paralelismo:
Go foi projetada com suporte integrado para concorrência e
paralelismo. Ela possui primitivas de concorrência, como
goroutines (unidades leves de execução) e canais (mecanismo de
comunicação entre goroutines), facilitando a construção de
programas concorrentes de maneira eficiente

Coleta de Lixo Eficiente:

Go possui um coletor de lixo eficiente que gerencia
automaticamente a alocação e liberação de memória, aliviando os
desenvolvedores da responsabilidade de gerenciar manualmente a
alocação e desalocação de memória.

Simplicidade e Legibilidade:
Go foi projetada com uma sintaxe simples e clara. A linguagem
evita recursos complexos e excessivamente abstratos, o que
facilita a leitura e manutenção do código. A ideia é que o código
seja claro e compreensível sem a necessidade de muita
explicação.
 6
Compilação Rápida:
Go é uma linguagem compilada e a compilação é rápida, o que
ajuda no desenvolvimento eficiente. Ela também suporta a
compilação cruzada, permitindo que você compile o código para
diferentes sistemas operacionais e arquiteturas.

Gerenciamento de Dependências Integrado:

O Go possui uma ferramenta integrada para gerenciamento de
dependências chamada "go modules". Isso facilita o controle e a
gestão das dependências do projeto.

Orientação a Interfaces:
Go segue um paradigma de programação orientada a interfaces.
Em vez de depender de herança de classes, o Go incentiva a
composição de tipos através de interfaces, proporcionando
flexibilidade e reutilização de código.

Ferramentas de Teste Integradas:

Go possui um sistema de teste integrado, facilitando a escrita e
execução de testes unitários e de integração.

Suporte a Programação de Baixo Nível:

Go oferece suporte a programação de baixo nível quando
necessário, incluindo a capacidade de manipular ponteiros, embora
a linguagem incentive um estilo de programação seguro.
A linguagem Go tem sido amplamente adotada em diversos
projetos, desde desenvolvimento de sistemas distribuídos até
aplicações de servidores web. Seu design focado na simplicidade,
eficiência e concorrência a torna uma escolha popular para muitos
desenvolvedores.
 7

2. Configurando ambiente

Para começarmos a programar em Go, precisamos inicialmente

configurar o nosso ambiente de desenvolvimento. Veja os passos
de como configurar o seu ambiente de acordo com o seu sistema
operacional:

Windows 10 (ou superior):

Passo 1 - Download do Instalador:

Primeiramente, comece acessando https://go.dev/dl/ para baixar a
versão binária mais recente do instalador Go. Certifique-se de
selecionar a versão compatível com o seu sistema operacional
(Windows).

A imagem acima mostra como primeira opção a versão correta

para a instalação do Go.

Passo 2 - Download do Instalador:

 8
Procure no seu computador o arquivo baixado e o execute. Siga as
instruções na tela para concluir a instalação do Go em seu sistema.
As imagens abaixo mostram como o instalador se comporta:
9
 10

Clicando em finish, a instalação do Go no seu sistema estará

concluída.

Passo 4 - Testar a Instalação:

Após concluir a instalação, basta abrir o Prompt de Comando
(CMD) ou Windows PowerShell e digitar o comando go version e
verificar se aparece a versão Go instalada. Veja os exemplos:

CMD:
C:\Users\Kage Jinsei> go version
go version go1.21.5 windows/amd64

PowerShell:
PS C:\Users\Kage Jinsei> go version
go version go1.21.5 windows/amd64

Pronto! Agora o Go está instalado no seu sistema Windows, você já

pode criar e executar programas Go.
 11
Linux:

A instalação do Go em ambiente Linux é um pouco diferente,

podemos fazer de duas formas, siga os passos abaixo:

Passo 1 - Download:
Como mencionado anteriormente, existem duas formas de fazer a
instalação do Go no Linux, a primeira delas é pelo gerenciador de
pacotes da sua distribuição Linux. Segue abaixo algumas
distribuições e a forma de instalação:

Debian/Ubuntu:
- sudo apt update && sudo apt upgrade
- sudo apt install golang

Arch/Manjaro:
- sudo pacman -Syyu
- sudo pacman -S go

Fedora:
- sudo dnf check-update && sudo dnf upgrade
- sudo dnf install go

OpenSUSE:
- sudo zyper update
- sudo zypper install go

Os comandos citados acima sincronizam e atualizam os

repositórios de cada distribuição e instala o Go. porém, é
importante lembrar: nem sempre o repositório da sua
distribuição estará com a versão mais atua do Go.
 12
Caso opte pela instalação manual com a versão binária, siga os
seguintes passos:

Passo 1 - Download do Instalador:

Acesse https://go.dev/dl/ e faça e baixe a versão binária mais
recente do instalador Go. Certifique-se de selecionar a versão
compatível com o seu sistema operacional (Linux).

A imagem acima mostra as versões de instaladores Go, sendo a

quarta opção a correta para os sistemas Linux.

Passo 2 – Descompactar Arquivo Baixado:

1 – abra o seu terminal e encontre o local onde o arquivo binário foi
baixado (ex: Downloads). Se o arquivo estiver na pasta Downloads,
abra a pasta utilizando o comando: cd Downloads

2 – já na pasta do instalador, siga esses passos:

a. para utilizar o próximo comando, você precisa de acesso root,

então, digite o comando: su
b. após o comando su, será necessário digitar a sua senha de
super usuário, faça isso e conseguirá prosseguir na instalação.

c. já no modo super usuário, utilize o seguinte comando:

rm -rf /usr/local/go && tar -C /usr/local -xzf go1.21.5.linux-amd64.tar.gz
 13

O comando acima estará removendo versões anteriores do Go da

pasta /usr/local (rm -rf /usr/local/go) e vai estar descompactando o
arquivo novo no mesmo local (tar -C /usr/local -xzf go1.21.5.linux-
amd64.tar.gz).

IMPORTANTE: fique atendo ao nome do seu arquivo, pois no momento

atual (05/01/24) a versão atual do Go é a 1.21.5, dependendo da época
em que estiver vendo isso o comando será diferente. Para evitar
problemas durante a instalação, após o “rm -rf /usr/local/go && tar -C
/usr/local -xzf” copie e cole o nome do arquivo que você baixou. Segue
o exemplo:
rm -rf /usr/local/go && tar -C /usr/local -xzf go.x.xx.x.linux-amd64.tar.gz

O comando acima mostra após o “-xzf” uma versão do Go onde o

número da versão é representado por “x”. Lembre-se de substituir
“x.xx.x” pelo número da versão específica do Go que você baixou.

Passo 3 – Configurar Variável de Ambiente:

Para isso, você pode sair do modo root digitando o comando: exit

Agora, digite o seguinte comando no seu terminal:

export PATH=$PATH:/usr/local/go/bin

Após isso, você precisa aplicar as alterações. Para fazer aplicar as

alterações, vai depender do shell que o seu terminal está
utilizando. Para verificar isso, utilize o comando: echo $SHELL

Se o seu terminal retornar “/bin/bash” você está utilizando bash,

caso retorne “/bin/zsh” está utilizando zsh.
Para aplicar as alterações, utilize o comando de acordo com o seu
shell:

Bash:
 14
- source ~/.bashrc

Zsh:
- source ~/.zshrc

Passo 4 - Testar a Instalação:

Para finalizar, ainda no seu terminal, utilize o comando: go version

para verificar se a instalação foi bem sucedida. Você receberá o
seguinte retorno:

Terminal:
> go version
go version go1.21.5 linux/amd64

Agora, o Go já está instalado no seu sistema Linux, você já pode

criar e executar programas Go.
 15
Instalando e Configurando Editor de Código:

Passo 1 - Download do Instalador:

Você pode utilizar o editor de código ou IDE que desejar, contanto
que tenha suporte. Por aqui, utilizaremos o Visual Studio Code.
Para baixar e instalar o Visual Studio Code, acesse o site oficial e
faça o download da versão compatível com o seu sistema. Após
baixar, é só abrir o instalador e executar os passos necessários.
Link do site: https://code.visualstudio.com/download.
Após instalar o Visual Studio Code, abra o programa e você verá
uma interface assim:

Assim que abrir o Visual Studio Code, na tela inicial, clique na

opção open folder. Abrirá uma nova aba onde você selecionará
uma pasta para criar os seus arquivos Go.
Recomendo que pesquisem sobre a estrutura de diretórios em Go,
será importante para futuros projetos. Por aqui, iremos simplificar.
 16
Quando selecionar a pasta, essa será a próxima tela:

Clique em “Yes, I trust the authors” e a sua pasta aparecerá no

EXPLORER, que fica localizado na parte superior esquerda da tela.

Passo 2 – Instalando Extensão e Configurando para usar o Go:

Para instalar extensões, utilize CTRL + SHIFT + X para abrir as
extensões, ou clique no último ícone que aparece na parte lateral,
como mostra na imagem a seguir:
 17
Na barra de pesquisas, digite “Go” e instale a extensão. Segue a
extensão correta:

Quando concluir a instalação, vamos abir o Command Palette

usando CTRL + SHIFT + P, ou indo na engrenagem no canto
inferior esquerdo. Depois, procure por Go: Install/Update Tools.
 18
Clicando em Go: Install/Update Tools,abrirá uma nova aba:

Selecione todas as ferramentas e clique em OK. Um terminal será

aberto e começará a atualização das ferramentas, aguarde até que
conclua todas as atualizações.

Quando concluir as atualizações o terminal mostrará:

Pronto, tudo certo para rodar programas Go na sua máquina.

 19

3. Estrutura básica do programa

A estrutura básica de um programa Go é relativamente simples.

Veja um exemplo:

Agora, vamos entender um pouco sobre o que está acontecendo

na estrutura acima:

Pacote (package):
Cada arquivo Go pertence a um pacote, e o pacote principal de um
programa executável deve ser chamado de main. Isso indica que é
um programa executável.

Imports (import):
Após a declaração do pacote, você pode importar outros pacotes
necessários para o seu programa. No exemplo, estamos
importando o pacote "fmt" para formatação de saída.
 20
Função Principal (func main()):
Todo programa Go executável deve ter uma função chamada main.
Esta é a função que será executada quando o programa for
iniciado. O código dentro desta função será a entrada principal do
seu programa.

Corpo da Função Principal:

O corpo da função main contém o código que será executado
quando o programa for iniciado. No exemplo, estamos usando a
função fmt.Println para imprimir "Hello, Go!" no console.
Esta é uma estrutura básica, e programas Go podem evoluir para
incluir várias funções, pacotes, e estruturas de controle de fluxo. No
entanto, todos os programas Go devem ter uma função main no
pacote principal para começar a execução.

Esta é uma estrutura básica, e programas Go podem evoluir para

incluir várias funções, pacotes, e estruturas de controle de fluxo. No
entanto, todos os programas Go devem ter uma função main no
pacote principal para começar a execução.

Agora que você já entende a estrutura básica de um programa,

faremos o nosso primeiro programa em Go.
 21

4. Módulos

Em Go, quando iniciamos um novo projeto, sempre começaremos

com o comando go mod init. Ele é usado em Go para inicializar um
novo módulo (ou converter um projeto existente em um módulo).
A introdução de módulos no Go é uma maneira de gerenciar
dependências e versionamento de maneira mais eficiente.
Aqui estão algumas razões pelas quais você deve usar o go mod
init:

Gerenciamento de Dependências:
Ao iniciar um módulo com go mod init, você está criando um
ambiente onde o Go pode gerenciar suas dependências de forma
estruturada. O arquivo go.mod resultante conterá informações
sobre os módulos usados pelo seu projeto, incluindo suas versões.

Controle de Versão:
O go.mod inclui informações sobre as versões específicas das
dependências utilizadas no projeto. Isso garante que, ao
compartilhar o código ou ao reproduzi-lo em outro ambiente, as
mesmas versões das dependências serão usadas, promovendo
consistência.

Facilita a Colaboração:
O uso de módulos torna mais fácil para outros desenvolvedores
colaborarem no seu projeto. Eles podem clonar o repositório e, ao
executar go get, o Go baixará automaticamente as dependências
corretas.
 22
Compatibilidade com Versionamento Semântico:
O Go incentiva o uso de versionamento semântico (SemVer) para
módulos. Isso significa que você pode especificar regras claras
sobre como suas dependências podem ser atualizadas, evitando
surpresas em atualizações automáticas.
Simplifica o Controle de Versão com Git:
Quando você inicializa um módulo, o go mod init também cria
automaticamente uma entrada no arquivo .gitignore para ignorar o
diretório vendor/ (onde as dependências são armazenadas). Isso
ajuda a manter o controle de versão do seu projeto mais limpo.

Facilita a Migração para o Go Modules:

Para projetos mais antigos, a introdução de módulos pode ser uma
tarefa incremental. Usar go mod init é um primeiro passo essencial
para migrar um projeto existente para o sistema de módulos.

Iniciando o módulo:

Para iniciar um módulo no seu projeto, certifique-se de estar com o

editor de códigos aberto.
No seu editor de códigos, abra a pasta onde iniciaremos o módulo.
Após isso, na parte superior esquerda clique em Terminal, depois
em New Terminal para abrir o terminal.
Abrindo o terminal, verifique se está na pasta correta. No exemplo
a seguir, a pasta se chama Golang e está dentro da pasta
Documentos.
 23

No desenvolvimento real, o caminho do módulo será o local do

repositório onde o seu código-fonte será mantido, por exemplo:
go mod init github.com/meumodulo

Como o objetivo não é passar um projeto real, utilizaremos apenas

um exemplo
Inicie o módulo utilizando o seguinte comando:
go mod init hello/example

Um novo arquivo chamado go.mod será criado na sua pasta.

 24

5. Olá, Mundo!

Finalmente estaremos escrevendo os nossos primeiros códigos em

Go, e não poderia ser diferente, né?, começaremos com o famoso
“Olá, Mundo!
Existe uma lenda no mundo da programação que diz que aquele
que não cria o seu primeiro código imprimindo “Olá, Mundo!”
receberá uma maldição. Como não queremos ser amaldiçoados,
vamos fazer o nosso primeiro “Olá, Mundo!” em Go.
Primeiramente, crie uma pasta chamada helloworld dentro da pasta
onde o arquivo go.mod foi criado. Dentro da pasta helloworld, crie
um arquivo chamado hello.go e, dentro do arquivo, digite os
comandos necessários para criar o seu primeiro programa.
Segue o exemplo abaixo:

Dentro da pasta Golang temos o nosso arquivo go.mod, a nossa

pasta helloworld e, dentro dela, o arquivo hello.go. Ao lado, temos o
arquivo hello.go aberto mostrando o códiglo utilizado para criar o
nosso primeiro programa que imprime o texto “Olá, Mundo!” na
tela.
 25
Vamos verificar a sintaxe do seu primeiro código:

O package main é uma declaração especial que indica que este é

um programa executável e não uma biblioteca. Em Go, cada
programa executável deve ter um pacote chamado main.

A declaração import “fmt” em Go é usada para importar o pacote

“fmt”, que fornece funcionalidades para formatar a saída no
programa. O pacote “fmt” é uma parte da biblioteca padrão do Go e
oferece diversas funções para imprimir dados formatados. A função
mais comum do pacote “fmt” é Println, que é a que estamos
usando. Ela é usada para imprimir uma linha.

Também temos func main(), que é a função main. A função main

em Go é especial e desempenha um papel fundamental em
programas executáveis. Ela serve como o ponto de entrada do
programa, sendo o primeiro código a ser executado quando o
programa é iniciado. Como foi mostrado na imagem anterior, após
declarar a função, abrimos chaves ({}) e, dentro de chaves,
colocamos o código que desejamos executar. Quando um
programa Go é iniciado, o código dentro da função main é o
primeiro a ser executado.

E por fim, o fmt.Println(”Olá, Mundo!”) é uma chamada à função

Println, do pacote “fmt”. Esta expressão é frequentemente usada
nos primeiros exemplos de programas Go, especialmente no
famoso exemplo “Olá, Mundo!”. A função Println é utilizada quando
queremos imprimir algo na tela (neste exemplo, uma string, que é o
texto que está entre aspas duplas).
 26
Vamos ver como o nosso código roda. Siga esses passos:

Passo 1 - Abrindo Terminal:

Primeiramente, clique com o botão direito na pasta onde o seu
arquivo hello.go está, em seguida, clique em “Open in Integrated
Terminal”.

Passo 2 – Executando o Programa:

No terminal, usaremos o comando go run para compilar e executar
programas em Go em um único comando. Ele simplifica o processo
de desenvolvimento, permitindo que você teste e execute
rapidamente seu código sem a necessidade de criar um arquivo
executável separado. Utilize go run hello.go.
 27

6. Comentários

Comentários em código servem para fornecer informações

adicionais que não são executadas pelo compilador ou
interpretador da linguagem, mas são úteis para os
desenvolvedores que leem ou mantêm o código. Aqui estão
algumas razões pelas quais os comentários são importantes:

Explicação do Código:
Comentários ajudam a explicar o propósito, a lógica e a
funcionalidade do código. Isso torna mais fácil para outros
desenvolvedores entenderem o que o código está fazendo.

Documentação do Código:
Comentários podem servir como uma forma de documentação
embutida, fornecendo informações sobre como usar funções,
classes ou módulos específicos.

Anotações para Desenvolvedores Futuros:

Comentários podem ser úteis para fornecer insights sobre decisões
de design, possíveis melhorias ou considerações para
desenvolvedores futuros que podem precisar modificar ou estender
o código.

Lembre-se de que a prática de adicionar comentários deve ser

equilibrada. Códigos autoexplicativos e bem organizados
geralmente precisam de menos comentários. Comentários em
excesso ou comentários que não estão sincronizados com o código
real podem se tornar obsoletos e prejudicar a manutenção.
 28
Em Go, os comentários são semelhantes a outras linguagens de
programação e podem ser usados para fornecer informações
adicionais no código fonte. Aqui estão alguns detalhes sobre os
comentários em Go:

Comentários de Linha Única:

Comentários de linha única são iniciados com //. Tudo na linha
após // é considerado um comentário.

Comentários de Múltiplas Linhas:

Os comentários de múltiplas linhas começam com /* e terminam
com */.

Também é possível comentar ao lado do seu código, para isso,

utilize // ao lado do código que deseja escrever algo e estará
fazendo um comentário.
 29

7. Tipos, valores e variáveis

Variáveis em programação são espaços de armazenamento com

um nome simbólico (identificador) associado, que contêm dados ou
valores manipulados por um programa. Em outras palavras, uma
variável é um contêiner que armazena informações e pode ser
referenciado ou manipulado em um programa de computador.

Em Go, assim como em muitas outras linguagens de programação,

há conceitos fundamentais relacionados a tipos, valores e
variáveis. Aqui estão explicações sobre cada um desses conceitos
em Go:

Tipos:
Go é uma linguagem de programação estaticamente tipada, o que
significa que as variáveis têm tipos definidos em tempo de
compilação. Os tipos em Go incluem tipos básicos (inteiros, ponto
flutuante, booleanos, etc.) e tipos compostos (structs, slices, maps,
arrays, etc.).
Exemplos de tipos básicos:
 30
Exemplos de tipos compostos:

Valores:
Os valores são as instâncias específicas de um tipo. Por exemplo,
42 é um valor do tipo int, e "Olá" é um valor do tipo string.
Os valores em Go têm zero values, o que significa que, se você
declara uma variável sem atribuir um valor, ela receberá um valor
padrão dependendo do tipo. Veja um exemplo:

Variáveis:
Variáveis em Go são espaços de armazenamento com um nome
que armazenam valores de um tipo específico.
Você declara variáveis usando a palavra-chave var, seguida pelo
nome da variável e seu tipo, e pode inicializá-las com um valor.
 31
Em Go, também existe a variável inferida, que refere-se à
capacidade do compilador de decidir automaticamente o tipo de
uma variável com base no valor que está sendo atribuído a ela. A
declaração curta de variáveis “:=” é a principal maneira de criar
variáveis inferidas em Go.
Aqui está um exemplo simples:

Nesses casos, como mencionado anteriormente, o compilador irá

definir automaticamente os tipos, sendo:

- nome é inferido como string.

- idade é inferido como int.
- altura é inferido como float64.

Importante: não é possível criar uma variável usando “:=” sem

atribuir um valor a ela

Essa abordagem torna a declaração de variáveis mais concisa e

ajuda a reduzir a redundância no código. No entanto, é importante
observar que a inferência de tipo só é permitida dentro de funções.
Fora de funções, você deve usar a forma tradicional de declaração
de variáveis com var.
 32
Regra de Nomeação de Variáveis:

Assim como em outras linguagens, Go tem uma regra para a

nomeação de variáveis, veja:

- O nome de uma variável pode começar com o caractere (“_”)

- O nome de uma variável não pode começar com número (ex: 1);
- O nome de uma variável não pode conter espaços;
- O nome de uma variável não pode ser nenhuma palavra-chave
Go (ex: var, println etc.);
- O nome de uma variável só pode conter caracteres
alfanuméricos e sublinhados (a-z, A-Z, 0-9 e ”_“);
- O nome de uma variável é exatamente aquele que você colocou,
ou seja, se você utilizar uma letra maiúscula quando declara a
variável, deve colocar a mesma letra maiúscula quando chamar a
variável (ex: nome, Nome e NOME são variáveis diferentes);
- Não existe um limite para o comprimento do nome da variável;

Existem técnicas que você pode utilizar para criar as suas

variáveis, veja algumas:

Cada variável tem um estilo diferente, cada estilo tem o seu nome.
 33

8. Constantes
Em Go, constantes são valores fixos que não variam durante a
execução do programa. Elas oferecem uma maneira de nomear e
utilizar valores imutáveis que são conhecidos em tempo de
compilação. A declaração de constantes é realizada mediante o
uso da palavra-chave const, seguida pelo nome da constante e
pelo valor que lhe é atribuído. Este mecanismo proporciona clareza
e consistência ao código, sendo especialmente útil para
representar valores que não devem ser alterados ao longo da
execução do programa, como constantes matemáticas, limites ou
códigos predefinidos.

Aqui estão alguns pontos importantes sobre constantes em Go:

Declaração de Constantes:
Para declarar uma constante, use a palavra-chave const seguida
pelo nome da constante e pelo valor.
 34
Tipos em Constantes:
Ao contrário das variáveis, você não precisa especificar
explicitamente o tipo da constante, pois o compilador infere o tipo
com base no contexto. Mas também é possível declarar o tipo.

Valores de Expressões Constantes:

Os valores de expressões constantes devem ser determinados em
tempo de compilação. Isso significa que você não pode usar
funções ou resultados de tempo de execução para inicializar uma
constante. Neste exemplo, a função math.Sqrt é chamada para
calcular a raiz quadrada de 25. Como esse cálculo só pode ser
feito em tempo de execução, não é permitido usar esse valor para
inicializar uma constante.
 35
Enumerando Constantes:
Você pode criar uma lista de constantes enumeradas usando a
palavra-chave iota, que é um identificador que representa valores
inteiros incrementados automaticamente.

Constantes Não Tipadas:

As constantes em Go são não tipadas, o que significa que podem
ser usadas em diferentes contextos sem a necessidade de
conversão explícita.
 36
Constantes Exportadas:
Constantes exportadas (iniciadas com letra maiúscula) são visíveis
fora do pacote, enquanto constantes não exportadas (iniciadas com
letra minúscula) são visíveis apenas dentro do pacote.
 37

9. Outputs

Em Go, a formatação de saída é comumente realizada utilizando o

pacote “fmt”. Este pacote fornece funções como Print, Println e
Printf para exibir informações no console ou em outros destinos de
saída. Além disso, o pacote “fmt” também oferece verbos de
formatação, que são especificadores utilizados para formatar
valores de acordo com seus tipos.

fmt.Print() - Impressão Simples:

A função Print é utilizada para imprimir valores no console sem
adicionar uma nova linha ao final. Ela aceita uma lista variável de
argumentos e os imprime consecutivamente.
Exemplo:

fmt.Println() - Impressão com Nova Linha:

A função Println é semelhante à Print, mas adiciona
automaticamente uma nova linha ao final da saída. Isso é útil para
separar as linhas de saída.
Exemplo:
 38

fmt.Printf() - Impressão com Formatação:

A função Printf permite formatação de string usando verbos
específicos, sendo semelhante à função Printf em C. Ela aceita
uma string de formato e uma lista variável de argumentos que
serão formatados e impressos.
Exemplo:

Essas funções do pacote “fmt” são fundamentais para exibir

informações no console de maneira fácil e eficiente. A escolha
entre Print, Println, ou Printf depende das necessidades específicas
de formatação e da presença ou ausência de nova linha ao final da
saída.
 39

10. Verbos de formatação

Em Go, os verbos de formatação são especificadores que indicam

como os valores devem ser formatados ao serem exibidos usando
a função Printf do pacote “fmt”. Aqui estão alguns dos verbos de
formatação mais comuns em Go:

%v (Verbo de Valor):
Utilizado para imprimir o valor de uma variável na sua forma
natural, sem formatação específica.

%d (Verbo Decimal):
Utilizado para formatar números inteiros.
 40
%f (Verbo Ponto Flutuante):
Utilizado para formatar números de ponto flutuante.

%s (Verbo String):
Utilizado para formatar strings.
 41
%t (Verbo Booleano):
Utilizado para formatar valores booleanos.

%b (Verbo Binário):
Utilizado para formatar números em representação binária.

Esses são apenas alguns dos verbos de formatação disponíveis

em Go, existem diversos. A escolha do verbo depende do tipo de
valor que você está formatando e do resultado desejado na saída
formatada.
 42

11. Tipos de dados

Os tipos de dados em Go são essenciais para definir como os

valores são armazenados na memória, interpretados e
manipulados pelo programa. Cada variável em Go possui um tipo
de dados associado, que determina as operações que podem ser
realizadas com ela, a quantidade de memória que ela ocupa e a
forma como ela é representada internamente.
Go é uma linguagem estaticamente tipada, ou seja, uma vez que
for definido um tipo numa variável, ela só poderá armazenar dados
desse tipo.
Esses são os três tipos básicos de dados em Go:

- bool: representa um valor booleano, que será falso ou

verdadeiro;
- numérico: representa tipos inteiros, valores de ponto flutuante e
tipos complexos;
- string: representa uma sequência de caracteres.

Aqui está um exemplo dos tipos de dados básicos em Go:

 43
Boolean:

Em Go, o tipo de dado bool representa valores booleanos, que

podem ter apenas dois estados: verdadeiro (true) ou falso (false). O
tipo bool é frequentemente utilizado em expressões condicionais,
estruturas de controle de fluxo e operações lógicas.

Aqui estão alguns pontos importantes sobre o tipo bool em Go:

Declaração de Variáveis:
Você pode declarar variáveis do tipo bool da seguinte maneira:

Ou, usando inferência de tipo:

O tipo bool é simples, mas é uma peça fundamental na

programação, sendo essencial para tomada de decisões e controle
de fluxo em algoritmos e lógica condicional.
 44
Integer:

Em Go, os tipos de dados inteiros são usados para representar

números inteiros. Go fornece vários tipos de inteiros, com
diferentes tamanhos e faixas, para atender a diferentes
necessidades de programação.
O tipo de dados inteiro possui duas categorias:
- Inteiros assinados: armazenam valores positivos e negativos;
- Inteiros não-assinados: armazenam apenas não negativos.

Importante: o tipo padrão para inteiro é int. Se você não

especificar um tipo, o tipo será int.

Signed Integers (Inteiros Assinados):

Em Go, os inteiros assinados são representados pelos tipos int e

outros tipos específicos, como int8, int16, int32 e int64. Esses tipos
são usados para armazenar números inteiros que podem ser
positivos, negativos ou zero, e têm a capacidade de representar o
sinal (positivo ou negativo) do número.
Aqui estão alguns detalhes sobre inteiros assinados em Go:

Tipo (int):
O tipo int representa inteiros com sinal. O tamanho do int é
dependente da arquitetura do sistema onde o código está sendo
compilado, sendo um int32 em sistemas de 32 bits e um int64 em
sistemas de 64 bits.
Exemplo:
 45

Existem cinco palavas-chave/tipos de inteiros assinados em Go,

cada um com o seu tamanho e faixa:

Tipo (int):
- Tamanho: depende da plataforma, sendo 32 bits em sistemas de
32 bits e 64 bits em sistemas de 64 bits.
- Faixa: -2147483648 a 2147483647 em sistemas de 32 bits e -
9223372036854775808 a 9223372036854775807 em sistemas de
64 bits.

Tipo (int8):
- Tamanho: 8 bits/1 byte.
- Faixa: -128 a 127.

Tipo (int16):
- Tamanho: 16 bits/2 bytes.
- Faixa: -32768 a 32767.

Tipo (int32):
- Tamanho: 32 bits/4 bytes.
- Faixa: -2147483648 a 2147483647.
 46

Tipo (int64):
- Tamanho: 64 bits/8 bytes.
- Faixa: -9223372036854775808 a 9223372036854775807.

Esses são os tipos de dados inteiros em Go, cada um com seu

tamanho e faixa específicos. O tipo int é dependente da plataforma,
o que significa que em sistemas de 32 bits, ele terá 32 bits, e em
sistemas de 64 bits, terá 64 bits. Os tipos fixos, como int8, int16,
int32 e int64, têm tamanhos fixos independentemente da
plataforma. Cada tipo tem um intervalo de valores que pode
representar, sendo importante considerar esses limites ao escolher
o tipo de dados apropriado para a sua aplicação.

Signed Integers (Inteiros não-assinados):

Em Go, os inteiros não assinados são representados pelos tipos

uint e outros tipos específicos, como uint8, uint16, uint32 e uint64.
Diferentemente dos inteiros assinados, os inteiros não assinados
representam apenas valores não negativos (zero e positivos) e não
têm um bit de sinal. Aqui estão alguns detalhes sobre inteiros não
assinados em Go:

uint:
O tipo uint representa inteiros sem sinal. O tamanho do uint é
dependente da arquitetura do sistema onde o código está sendo
compilado, sendo um uint32 em sistemas de 32 bits e um uint64
em sistemas de 64 bits.
Exemplo:
 47

Existem cinco palavas-chave/tipos de inteiros não-assinados em

Go, cada um com o seu tamanho e faixa:

Tipo(uint):
- Tamanho: depende da plataforma, sendo 32 bits em sistemas de
32 bits e 64 bits em sistemas de 64 bits.
- Faixa: 0 a 4294967295 em sistemas de 32 bits e 0 a
18446744073709551615 em sistemas de 64 bits.

Tipo(uint8):
- Tamanho: 8 bits/1 byte.
- Faixa: 0 a 255.

Tipo(uint16):
- Tamanho: 16 bits/2 bytes.
- Faixa: 0 a 65535.

Tipo(uint32):
- Tamanho: 32 bits/4 bytes.
- Faixa: 0 a 4294967295.

Tipo(uint64):
 48
- Tamanho: 64 bits/8 bytes.
- Faixa: 0 a 18446744073709551615.

Esses são os tipos de dados inteiros não assinados em Go, cada

um com seu tamanho e faixa específicos. Os tipos uint e suas
variantes representam valores que são sempre não negativos,
incluindo zero e valores positivos, e são frequentemente usados
quando você precisa representar quantidades que não fazem
sentido como valores negativos.
 49
Float:

O tipo de dados float em programação, incluindo em Go, é usado

para armazenar valores numéricos que representam números de
ponto flutuante, ou seja, números reais. Esses números podem ter
parte inteira e parte fracionária, permitindo a representação de
valores não inteiros, como números decimais.
O tipo de dados float possui duas palavras-chave:

Tipo(float32):
- Tamanho: 32 bits (4 bytes).
- Precisão: aproximadamente 7 dígitos decimais de precisão.
- Faixa: aproximadamente de -3.4e+38 a 3.4e+38.
- Significado: O tipo float32 em Go representa números de ponto
flutuante (números reais) com 32 bits de precisão. Isso significa
que pode representar números decimais com até sete dígitos
significativos, e sua faixa de valores vai de aproximadamente -3.4
vezes 10 elevado a 38 até 3.4 vezes 10 elevado a 38.
Exemplo:
 50
Tipo(float64):
- Tamanho: 64 bits (8 bytes).
- Precisão: aproximadamente 15 dígitos decimais de precisão.
- Faixa: aproximadamente de -1.7e+308 a +1.7e+308.
- Significado: O tipo float64 em Go representa números de ponto
flutuante com maior precisão, usando 64 bits. Isso permite
representar números decimais com até 15 dígitos significativos. A
faixa de valores do float64 vai de aproximadamente -1.7 vezes 10
elevado a 308 até 1.7 vezes 10 elevado a 308.
Exemplo:

Em resumo, a principal diferença entre float32 e float64 está na

precisão e na faixa de valores que podem ser representados. O
float64 oferece maior precisão, mas também ocupa mais espaço
em memória, sendo a escolha preferida quando a precisão é
crucial, como em cálculos científicos. O float32 é usado quando se
deseja economizar espaço e a precisão adicional não é necessária.
 51
String:

O tipo de dados string é empregado para armazenar sequências de

caracteres, ou seja, texto. Os valores atribuídos a uma string
devem ser delimitados por aspas duplas. Essa representação é
fundamental para trabalhar com dados textuais em Go,
proporcionando uma maneira consistente e eficiente de lidar com
informações como palavras, frases e outras formas de texto.
Aqui estão algumas características importantes sobre strings em
Go:

Declaração de Strings:
Você pode declarar uma string usando aspas duplas.

Imutabilidade:
Strings em Go são imutáveis, o que significa que, uma vez criada,
não é possível modificar seus caracteres individualmente. As
operações que parecem modificar uma string, na verdade, criam
uma nova string.

As strings em Go são projetadas para serem eficientes, e a

codificação em UTF-8 permite a manipulação eficaz de caracteres
em diferentes idiomas. A imutabilidade das strings promove a
segurança na manipulação de dados e evita comportamentos
inesperados. O pacote strings oferece funcionalidades adicionais
para facilitar o trabalho com strings de maneira eficiente.
 52

12. Arrays

Em Go, um array é um tipo de estrutura de dados que permite

armazenar uma coleção fixa de elementos do mesmo tipo, ou seja,
uma variável que armazena valores do mesmo tipo. Ao serem
declarados, os arrays têm um tamanho predefinido que não pode
ser alterado após sua criação. Alguns pontos essenciais sobre
arrays em Go incluem:

Declaração de Arrays:
Arrays são declarados especificando o tipo dos elementos e seu
tamanho. A sintaxe básica é utilizando “var” é:

Com o sinal “:=” é assim:

Importante: A dimensão especifica a quantidade de elementos a

serem armazenados no array. Em Go, os arrays possuem uma
dimensão fixa. Essa dimensão é definida explicitamente por um
número ou inferida pelo compilador (o que significa que o
compilador decide a dimensão do array com base no número de
valores fornecidos).
 53
Acesso a Elementos de um Array:
Você pode acessar um elemento específico do array consultando
seu número de índice.
Em Go, os índices do array começam em 0. Isso significa que [0] é
o primeiro elemento, [1] é o segundo elemento, etc.
Exemplo:

Alterar Elementos de um Array:

Você também pode alterar o valor de um elemento específico da
matriz consultando o número do índice.
Exemplo:

Inicialização de Arrays:
Se um array ou qualquer um de seus elementos não for
explicitamente inicializado no código, será atribuído a eles o valor
padrão correspondente ao seu tipo. É relevante notar que, para o
tipo “int”, o valor padrão é 0, enquanto para o tipo “string”, o valor
padrão é uma string vazia, representada por "". Essa característica
 54
garante consistência e previsibilidade quando não há uma
inicialização explícita, proporcionando valores padrão coerentes
com os tipos de dados envolvidos.
Exemplo:

Inicialização de Elementos Específicos em Arrays:

É possível inicializar apenas elementos específicos de um array.
Exemplo:

Explicando o exemplo acima:

O array possui 7 elementos ([7]), ao utilizar “0:10”, estou atribuindo
o valor “10” ao índice 0 do array (primeiro elemento). O “6:70”
indica que estou atribuindo 70 ao índice 6 (sétimo elemento).
 55
Comprimento de Arrays:
O tamanho de um array em Go é fixo e determinado durante a
declaração. Para obter o tamanho, utiliza-se a função "len".
Exemplo:

Os arrays em Go são uma ferramenta fundamental quando se

precisa de uma coleção fixa de elementos do mesmo tipo,
proporcionando um controle rígido sobre o tamanho da estrutura de
dados. Entretanto, para situações mais dinâmicas, as slices são
geralmente mais convenientes e amplamente utilizadas.
 56

13. Slices

As slices são estruturas semelhantes aos arrays, mas oferecem

maior poder e flexibilidade. Assim como os arrays, as slices são
utilizadas para armazenar vários valores do mesmo tipo em uma
única variável. No entanto, ao contrário dos arrays, as slices têm a
capacidade de alterar dinamicamente seu comprimento,
expandindo ou reduzindo conforme necessário. Essa característica
confere às slices uma adaptabilidade que as torna especialmente
úteis em situações onde a quantidade de dados pode variar ao
longo do tempo.
Em Go, existem várias formas de criar uma slice, veja:
Usando o formato: []Tipo{valores};
Criando uma slice de um array;
Usando a função make().

Criando uma Slice com o formato: []Tipo{valores}:

 57
Em Go, existem duas funções que podem ser usadas para retornar
o comprimento e a capacidade de uma fatia:
- Função len() - retorna o comprimento da slice (o número de
elementos na slice)
- Função cap() - retorna a capacidade da slice (o número de
elementos para os quais a slice pode aumentar ou diminuir)

len - Comprimento de uma Slice:

A função “len” retorna o número de elementos presentes em uma
slice. Por exemplo:

cap - Capacidade de uma Slice:

A função cap retorna a capacidade total da slice, ou seja, o número
máximo de elementos que a slice pode conter antes de precisar ser
realocada para um espaço maior na memória.

A capacidade é especialmente útil quando se trabalha com slices

que podem crescer dinamicamente, pois permite otimizar a
realocação de memória quando necessário.
 58
Ambas as funções são ferramentas valiosas ao manipular slices
em Go, proporcionando informações essenciais sobre a quantidade
atual de elementos e a capacidade disponível na estrutura de
dados.

Criando uma Slice de um Array:

Você pode criar uma slice fatiando um array.
Exemplo:

Veja outro exemplo:

No exemplo acima, minhaSlice é uma fatia com comprimento de 2.

Ela é feita a partir de minhaArray, que é um array com
comprimento 7.
A Slice começa no terceiro elemento do array que tem o valor 22
(lembre-se que os índices do array começam em 0. Isso significa
 59
que “0” é o primeiro elemento, 1 é o segundo e etc.). A slice pode
crescer até o final da array, isso significa que a capacidade da slice
é 5.

Criando uma Slice coma função make():

A função make() também pode ser utilizada para criar uma slice.

Importante: se o parâmetro capacidade não for definido, será igual

ao comprimento.

Este exemplo mostra como criar uma slice com a função make():
 60
Neste exemplo, make([]int, 3) cria uma slice de inteiros com um
comprimento inicial de 3. Em seguida, valores são atribuídos aos
elementos do slice.

Acessando Elementos de uma Slice:

Em Go, você pode acessar os elementos de uma slice usando
índices. O índice do primeiro elemento é 0, o segundo é 1, e assim
por diante. Aqui está um exemplo simples de como acessar
elementos de uma slice:

Neste exemplo, minhaSlice é uma slice de inteiros, com cinco

elementos. Os elementos são acessados usando “[ ]”, seguidos do
índice desejado (ex: índice [0] retorna o valor 10).

Alterando Elementos de uma Slice:

Você pode alterar os elementos de uma slice atribuindo um novo
valor a um elemento específico usando o índice correspondente.
Aqui está um exemplo mais detalhado de como fazer isso:
 61

Neste exemplo, minhaSlice é uma slice de inteiros inicializada com

três elementos. O elemento de índice [2] (terceiro elemento) sofreu
uma modificação, saindo do valor 30 para 8000.

Anexando Elementos numa Slice:

Você pode anexar elementos ao final de uma slice utilizando a
função “append()”:

Veja um exemplo:
 62
Neste exemplo, minhaSlice é uma slice de inteiros inicializada com
três elementos. A função append() é usada para adicionar novos
elementos à slice.

Anexando uma Slice numa Slice:

Para anexar todos os elementos de uma slice a outra slice, use a
função append().

Importante: O “…” após minhaSlice2 é necessário ao anexar os

elementos de uma slice a outra.

Aqui está um exemplo de como anexar uma slice a outra:

No exemplo acima, minhaSlice3 utiliza a função append() para

anexar minhaSlice e minhaSlice2. O resultado disso será a junção
dos elementos de minhaSlice e minhaSlice2.
 63
Eficiência de Memória:
Ao utilizar slices em Go, todos os elementos do array subjacente
são carregados na memória. Caso o array seja extenso e você
necessite apenas de alguns elementos, torna-se mais eficiente
copiar exclusivamente esses elementos utilizando a função copy().
A função copy() cria um novo array subjacente contendo apenas os
elementos essenciais para a slice de destino. Essa abordagem
contribui para a redução do consumo de memória do programa,
evitando a carga de dados não utilizados.
Portanto, ao empregar copy(), otimiza-se a alocação de memória,
assegurando que somente os dados relevantes sejam copiados
para a nova slice. Essa prática é particularmente valiosa ao lidar
com grandes conjuntos de dados, visando minimizar o impacto nos
recursos do sistema.
Este exemplo mostra como usar a função copy():

Neste exemplo, a função copy(destination, source) copia elementos

da slice source para a slice destination. A capacidade inicial da
destination é suficiente para armazenar três elementos, então
apenas os três primeiros elementos de source serão copiados.
 64

14. Operadores

Operadores são utilizados para executar operações em variáveis e

valores. Por exemplo, o operador “+” é usado para somar dois
valores. Veja o exemplo abaixo:

O operador “+” é comumente utilizado para adicionar dois valores,

mas também pode ser empregado para somar uma variável a um
valor ou para somar duas variáveis.
Exemplo:

Go divide os operadores nos seguintes grupos:

- Aritméticos;
- Atribuição;
- Comparação;
- Lógicos;
- Bit a Bit (Bitwise).
 65

Operadores aritméticos:

Operadores aritméticos são usados para realizar operações

matemáticas comuns. Veja a tabela com os operadores, nomes,
descrições e exemplos:

Operadores de atribuição:

Operadores de atribuição são usados para atribuir valores a

variáveis. No exemplo abaixo, o operador de atribuição (=) é usado
para atribuir o valor 15 a uma variável chamada valor:

O operador de atribuição de adição (+=) adiciona um valor a uma

variável:
 66

Uma lista de todos os operadores de atribuição:

Esta lista mostra exemplos e equivalências dos operadores de

atribuição compostos em Go, que simplificam a expressão de
operações frequentes.
 67
Operadores de comparação:

Operadores de comparação são usados para comparar dois

valores.

Importante: o valor de retorno de uma comparação é verdadeiro

(1) ou falso (0).

No exemplo a seguir, o operador maior que (>) é usado para

descobrir se 10 é maior que 5:

Uma lista de todos os operadores de comparação:

Essa tabela resume os operadores de comparação, descrevendo

seus nomes, exemplos de uso e a tradução correspondente.

Importante: você aprenderá mais sobre operadores de

comparação e como usá-los no capítulo Condições.
 68

Operadores lógicos:

Operadores lógicos são usados para determinar a lógica entre

variáveis ou valores. Aqui está uma lista de todos os operadores de
lógicos:

Essa tabela resume os operadores lógicos em Go, descrevendo

seus nomes, funções, exemplos de uso e a tradução
correspondente.
 69
Operadores bit a bit:

Operadores bit a bit são usados em números (binários).

Essa é a lista de todos os operadores bit a bit:
 70

15. Estruturas condicionais

Em Go, as estruturas condicionais, como “if”, “else if”, e “else”,

proporcionam o controle do fluxo de execução do programa
conforme determinadas condições. Essas construções permitem
que você tome decisões lógicas, adaptando o comportamento do
programa de acordo com os diferentes cenários que podem surgir
durante a execução.
Uma condição pode ser verdadeira ou falsa.
Go suporta os operadores de comparação usuais da matemática:

- Menos que: <

- Menor ou igual: <=
- Maior que: >
- Maior ou igual: >=
- Igual a: ==
- Diferente de: !=

Além disso, Go oferece suporte aos operadores lógicos usuais:

- Operador lógico “and”: &&

- Operador lógico “or”: ||
- Operador lógico “not”: !

Você pode usar esses operadores ou suas combinações para criar

condições para diferentes decisões.
 71

Declarando if:
A declaração if é usada para executar um bloco de código
condicionalmente, dependendo da avaliação de uma expressão
booleana. Veja a sintaxe básica:

Aqui está um exemplo básico de como declarar if em Go:

No exemplo acima, temos dois valores, sendo que, um deles, está

armazenado numa variável (idade). Testamos os dois valores para
descobrir se o valor armazenado na variável é maior que 17. Se a
condição for verdadeira, um texto é imprimido.
 72

Declarando else:
A declaração else em Go é usada em conjunto com a declaração if
para especificar um bloco de código a ser executado quando a
condição do if for falsa. Veja a sintaxe:

Aqui está um exemplo simples:

No exemplo acima, se a condição idade > 18 for verdadeira, o

bloco de código dentro do if será executado. Caso contrário, o
bloco de código dentro do else será executado.
 73
Importante: ao declarar eles, certifique-se de estar na linha certa,
caso contrário, um erro de sintaxe será gerado. Veja um exemplo:

Declarando else if:

A declaração else if em Go é utilizada para avaliar múltiplas
condições em sequência, permitindo que você lide com diferentes
cenários de maneira estruturada. Dê uma olhada na sintaxe:
 74
Aqui está um exemplo básico:

No exemplo acima, três blocos de código são associados a

diferentes condições:
Se nota for maior ou igual a 90, o primeiro bloco dentro do if é
executado, imprimindo "Excelente!".
Se a primeira condição não for atendida e nota for maior ou igual a
70, o segundo bloco dentro do else if é executado, imprimindo
"Bom trabalho!".
Se nenhuma das condições anteriores for verdadeira, o bloco
dentro do else é executado, imprimindo "É necessário melhorar.".
Essa estrutura permite que você lide com uma série de condições
de forma organizada e fornece flexibilidade para expressar a lógica
condicional do seu programa.
 75
Declarando if aninhado:
É possível utilizar estruturas if aninhadas para lidar com condições
mais complexas ou para realizar verificações adicionais em um
bloco condicional. Veja a sintaxe:

Aqui está um exemplo de como declarar if aninhados:

Neste exemplo, há um if aninhado dentro do bloco de código do

primeiro if. O segundo if verifica se o nome é "Alice" dentro do
 76
contexto de uma pessoa maior de idade. Dependendo das
condições, diferentes mensagens serão impressas.

Ao utilizar if aninhados, é essencial manter uma boa organização

no código para facilitar a leitura e compreensão. Essa técnica é útil
quando você precisa verificar várias condições em diferentes níveis
de hierarquia.
 77

16. Switch

Em Go, a declaração switch é uma maneira flexível e poderosa de

expressar estruturas condicionais em que você compara uma
expressão com vários valores possíveis.
A instrução switch em Go é semelhante à de outras linguagens
como C, C++, Java, JavaScript e PHP, mas com uma diferença
fundamental: em Go, não é necessário usar a instrução break após
a execução de uma case. A sintaxe básica é a seguinte:

É assim que funciona:

- A expressão é avaliada uma vez;
- O valor da expressão do switch é comparado com os valores de
cada case;
- Se houver uma correspondência, o bloco de código associado é
executado;
- A palavra-chave default é opcional. Ela especifica algum código
a ser executado se não houver correspondência de case.
 78

Aqui está um exemplo para ilustrar como o switch funciona:

Neste exemplo, a expressão diaDaSemana é comparada com

diferentes valores em cada case. O código dentro do bloco
correspondente ao primeiro caso cuja expressão é igual ao valor de
diaDaSemana será executado. Se nenhum dos casos coincidir, o
bloco dentro do default (se presente) será executado.
O switch em Go oferece uma alternativa concisa e eficaz às
estruturas condicionais if e é especialmente útil quando você
precisa comparar uma variável com vários valores possíveis. Além
disso, diferentemente de algumas outras linguagens, não é
necessário usar a instrução break após cada caso, pois o switch
em Go automaticamente sai da estrutura após a execução do bloco
correspondente.
 79
Importante: todos os valores de case devem ter o mesmo tipo que
a expressão switch. Caso contrário, o compilador gerará um erro.

Switch multi-case:

você pode ter vários valores correspondentes em um único caso do

switch. Isso é conhecido como "switch multi-case". A ideia é
fornecer uma lista de valores que serão tratados de maneira
semelhante quando comparados com a expressão do switch. Veja
a sintaxe:

Aqui está um exemplo de switch multi-case:

Neste exemplo, o primeiro case inclui vários dias úteis, e o

segundo case inclui dois dias de final de semana. Se a expressão
 80
dia corresponder a qualquer valor listado em um case, o bloco de
código correspondente será executado.

Isso torna o código mais conciso quando você precisa executar a

mesma lógica para vários valores. O uso de múltiplos valores em
um único caso economiza repetição de código e torna a estrutura
do switch mais clara.
 81

17. Loops

A estrutura de repetição for é bastante flexível e pode ser usada de

diferentes maneiras. Vamos explorar as formas mais comuns do
loop for em Go.

Forma Clássica (sintaxe):

- inicialização: É executado antes do primeiro loop. Pode ser

uma declaração de variável ou uma expressão.
- condição: É avaliada antes de cada iteração. Se for verdadeira,
o bloco de código dentro do for é executado; caso contrário, o loop
é encerrado.
- pós-execução: É executado após cada iteração.

Veja um exemplo que imprimirá os números de 0 a 4:

 82
Forma Simplificada:

Veja o mesmo exemplo na forma simplificada:

Loop Infinito:

A sintaxe é parecida com a forma simplificada, porém, o que muda

são as instruções que serão passadas.
 83
Declaração continue:
A instrução continue é usada para pular uma ou mais iterações no
loop. Em seguida, continua com a próxima iteração no loop.
Veja um exemplo onde o valor 5 é pulado:

O if i == 5 verifica se o valor de i é igual a 5. Se essa condição for

verdadeira, a instrução continue é executada. A instrução continue
pula para a próxima iteração do loop, ignorando o restante do
código dentro do loop que vem após a instrução continue. Portanto,
quando i é igual a 5, o bloco fmt.Println(i) é ignorado, e o loop
continua com a próxima iteração.
Como resultado, quando você executa esse código, o número 5
não será impresso na saída do programa, e os outros números de
0 a 10 serão impressos.
 84
Declaração break:
A instrução break é usada para interromper/encerrar a execução do
loop. Veja um exemplo onde o loop é interrompido:

O if i == 5 verifica se o valor de i é igual a i. Se essa condição for

verdadeira, a instrução break é executada. A instrução break
encerra imediatamente o loop em que está contida, ignorando o
restante do código dentro do loop.
Portanto, quando i atinge o valor 5, a condição if i == 5 se torna
verdadeira, e o break é executado, encerrando o loop
imediatamente. Isso significa que o bloco fmt.Println(i) não será
executado para i igual a 5 e nenhum número maior que 5 será
impresso.
Ao executar esse código, você verá a saída incluindo os números
de 0 a 4, mas não o 5, porque o loop é encerrado antes de chegar
a esse ponto.
 85
Importante: continue e break geralmente são usados com
condições.

Loops Aninhados:
Os loops aninhados em Go são uma construção onde um ou mais
loops estão contidos dentro de outro loop. Isso é útil quando você
precisa iterar sobre elementos em múltiplas dimensões, como em
matrizes bidimensionais ou em situações que exigem iterações
encadeadas.
Aqui está um exemplo simples de loops aninhados em Go, que
imprime um padrão de asteriscos em forma de retângulo:

Este exemplo utiliza dois loops aninhados: o loop externo controla

as linhas do retângulo, e o loop interno controla os asteriscos em
cada linha.

Os loops aninhados são frequentemente usados para lidar com

matrizes bidimensionais, padrões complexos ou qualquer situação
em que seja necessário iterar sobre múltiplos conjuntos de dados
encadeados.
 86
Palavra-chave range:
A palavra-chave range em Go é usada dentro de loops for para
iterar sobre elementos em uma variedade de tipos de dados, como
slices, arrays, strings, maps e canais. Ela simplifica o processo de
iteração, fornecendo valores do iterável e, opcionalmente, seus
índices.
Assim é a sintaxe básica:

Veja um exemplo simples utilizando range em uma slice:

Neste exemplo, o range é utilizado para percorrer o slice numeros.

A cada iteração do loop, indice recebe o índice atual e valor recebe
o valor correspondente no slice. O código dentro do loop imprime o
índice e o valor.
 87
O range é flexível e pode ser adaptado para diferentes tipos de
dados. Além disso, se você não precisar do índice, pode omiti-lo.
Por exemplo:

Neste caso, o “_” é usado para ignorar o índice, focando apenas

nos valores. O uso do range proporciona uma maneira concisa de
iterar sobre elementos de uma coleção em Go.
 88

18. Functions

Em Go, funções são blocos de código que realizam uma tarefa

específica. Elas são fundamentais para organizar e modularizar o
código em programas Go. Aqui estão alguns aspectos importantes
sobre funções em Go:

Sintaxe Básica:

Para criar (geralmente chamada de declaração) uma função, faça o

seguinte:
- Use a palavra-chave func;
- Especifique um nome para a função, seguido de parêntesis “()”;
- Adicione o código que define o que a função deve fazer, entre
chaves “{}”.

Chamando funções:
Funções não são executadas imediatamente. Elas são "salvas para
uso posterior" e serão executadas quando forem chamadas.
 89
No exemplo abaixo, uma função chamada "saudacao()". A chave
de abertura ({) indica o início do código da função, e a chave de
fechamento (}) indica o fim da função. A função produz a saída
"Olá, Mundo!". Para chamar a função, basta escrever o seu nome
seguido por dois parênteses “()” dentro da função main:

Também é possível chamar múltiplas funções, caso deseje:

 90
Regras de Nomeação para Funções:

- Um nome de função deve começar com uma letra.

- Um nome de função pode conter apenas caracteres
alfanuméricos e sublinhados (A-z, 0-9 e _ );
- Nomes de funções diferenciam maiúsculas de minúsculas;
- Um nome de função não pode conter espaços;
- Se o nome da função consistir em várias palavras, podem ser
utilizadas técnicas introduzidas para a nomeação de variáveis com
várias palavras.

Dica: Dê à função um nome que reflita o que ela faz.

Parâmetros e Argumentos:
As informações podem ser passadas para funções como
parâmetro. Os parâmetros atuam como variáveis dentro da função.
Os parâmetros e seus tipos são especificados após o nome da
função, entre parênteses. Você pode adicionar quantos parâmetros
quiser, basta separá-los com vírgula. Veja a sintaxe:
 91
No exemplo a seguir, existe a função saudacao() com o parâmetro
(nome) do tipo string. Quando a função saudacao() é chamada,
também passamos um nome (ex: Alice), e o nome é usado dentro
da função, que gera vários nomes diferentes com a mesma
mensagem ao lado:

Importante: quando um parâmetro é passado para a função, ele é

chamado de argumento. No exemplo acima, nome é um parâmetro,
enquanto Kage e Gwenhwyfar são argumentos.
 92
Múltiplos Parâmetros:
Em Go, você pode definir funções com múltiplos parâmetros para
receber diferentes valores durante a chamada da função. Aqui está
um exemplo de uma função com múltiplos parâmetros:

func saudacao(nome string, idade int): Aqui, está sendo

declarada uma função chamada saudacao. Ela recebe dois
parâmetros: nome (do tipo string) e idade (do tipo int). A função
imprime uma mensagem de saudação junto com o nome e a idade.
saudacao("Kage", 15): A primeira chamada da função saudacao
fornece os argumentos "Kage" e 15 para os parâmetros nome e
idade, respectivamente. A mensagem de saudação será impressa
usando esses valores.
saudacao("Gwenhwyfar", 1000): A segunda chamada da função
saudacao fornece os argumentos "Gwenhwyfar" e 1000 para os
parâmetros nome e idade, respectivamente. Novamente, a
mensagem será impressa usando esses valores.

Importante: ao trabalhar com vários parâmetros, a chamada de

função deve ter o mesmo número de argumentos que os
parâmetros, e os argumentos devem ser passados na mesma
ordem.
 93
Retorno de Valores:
Se quiser que a função retorne um valor, você precisa definir o tipo
de dados do valor de retorno (como int, string, etc) e também usar
a palavra-chave return dentro da função. Veja a sintaxe:

Veja um exemplo de função com retorno:

Neste exemplo, a função soma recebe dois parâmetros (a e b) e

retorna a soma desses dois valores como um inteiro. A palavra-
chave return é usada para indicar que a função está retornando o
valor resultante da expressão a + b.
Na função main, a função soma é chamada dentro da função
fmt.Println com dois argumentos (3 e 4), cujo a soma é impressa na
tela.
 94
Retorno de Valores Nomeados:
Em Go, você também pode nomear os valores de retorno de uma
função. Isso é útil quando uma função retorna múltiplos valores e
você deseja tornar o código mais legível. Aqui está um exemplo de
valores de retorno nomeados:

Neste exemplo, o valor de retorno foi nomeado como resultado (do

tipo int) e o valor é retornado com um retorno simples (significa que
a instrução return foi usada sem especificar o nome da variável).
O exemplo acima também pode ser escrito com a variável ao lado
do return (ex: return resultado).
 95
Retorno de Valores armazenados numa Variável:
O retorno de valores em Go pode ser armazenado diretamente em
variáveis nomeadas na declaração da função. Aqui está um
exemplo:

A função minhaFuncao recebe dois parâmetros (a e b) e retorna a

soma desses dois números. O valor de retorno é nomeado como
resultado.
Na função main, a função minhaFuncao é chamada com os
argumentos (1 e 2), e o resultado é armazenado na variável
nomeada somaTotal. Em seguida, o valor é impresso na tela.
 96
Múltiplos Valores de Retorno:
É possível retornar múltiplos valores em uma única função. Isso é
útil em situações em que você precisa fornecer mais de um
resultado. Aqui está um exemplo simples:

O que acontece no exemplo acima:

- A função calcularSomaEProduto recebe dois parâmetros (a e b)

e retorna dois valores: a soma e o produto desses dois números.
- Na função main, ao chamar a função, os valores de retorno são
armazenados diretamente nas variáveis nomeadas resultadoSoma
e resultadoProduto.
- Os valores armazenados são então impressos na tela.

Se, por algum motivo, não quisermos utilizar alguns dos valores
retornados de uma função, podemos adicionar um sublinhado ( _ )
para indicar que desejamos omitir esses valores. Essa prática é útil
quando estamos cientes dos valores de retorno, mas não temos a
intenção de utilizá-los na lógica subsequente do programa.
 97
Quando você usa o sublinhado ( _ ), está indicando ao compilador
que você não tem interesse em armazenar ou utilizar esse valor de
retorno específico. Veja um exemplo:

Neste exemplo, o valor de retorno do produto é ignorado usando

( _ ) no lado esquerdo da atribuição. Isso é útil quando você está
ciente do valor de retorno, mas não tem intenção de usá-lo na
lógica subsequente do programa.
 98
Funções Recursivas:
Em Go, é possível criar funções recursivas, ou seja, funções que
chamam a si mesmas. Aqui está um exemplo simples de uma
função recursiva que calcula o fatorial de um número:

No exemplo a seguir, contagem() é uma função que se chama

recursivamente (ou seja, chama a si mesma). Utilizamos a variável
x como os dados, os quais incrementam em 1 (x + 1) a cada
chamada recursiva. A recursão é encerrada quando a variável x é
igual a 6 (x == 6).

A recursão é um conceito comum em matemática e programação.

Isso oferece a vantagem de poder percorrer dados para atingir um
resultado.
 99
O desenvolvedor deve ter cuidado ao lidar com funções recursivas,
pois é relativamente fácil cair na armadilha de escrever uma função
que nunca termina ou que consome quantidades excessivas de
memória ou poder de processamento. No entanto, quando escrita
corretamente, a recursão pode ser uma abordagem muito eficiente
e matematicamente elegante para programar.

Um exemplo de uma função recursiva que calcula o fatorial:

A função fatorial é definida para calcular o fatorial de um número n.

A condição if n == 0 é o caso base, que retorna 1 quando n é igual
a zero.
A chamada recursiva return n * fatorial(n-1) ocorre para valores
diferentes de zero, calculando o fatorial de forma recursiva.
 100

19. Structs

Em Go, uma struct (estrutura) é um tipo de dado composto que

agrupa diferentes tipos de dados sob um único nome. Ela é
frequentemente utilizada para modelar conceitos mais complexos,
representando uma coleção de campos nomeados, onde cada
campo pode ter um tipo de dado diferente. As structs em Go são
uma forma de organizar e agrupar dados relacionados.
Enquanto arrays são usados para armazenar vários valores do
mesmo tipo de dados em uma única variável, structs são usadas
para armazenar vários valores de diferentes tipos de dados em
uma única variável. Cada campo dentro de uma struct pode ter um
tipo de dado diferente, e os campos são acessados por meio de
seus nomes.

A sintaxe básica de uma struct em Go é a seguinte:

NomeDaStruct: É o nome da struct.

Campo1, Campo2, ..., CampoN: São os nomes dos campos na
struct.
Tipo1, Tipo2, ..., TipoN: São os tipos de dados dos respectivos
campos.
 101
Aqui está um exemplo básico de uma struct em Go:

Neste exemplo:
Pessoa é uma struct que possui três campos: Nome (string), Idade
(int), e Altura (float64).
Uma instância da struct é criada com valores específicos para cada
campo.
Os campos da struct são acessados usando a notação de ponto
(pessoa1.Nome, pessoa1.Idade, pessoa1.Altura).
 102
Passando Struct como Argumento de Função:
Em Go, você pode passar uma struct como argumento para uma
função da mesma maneira que faria com qualquer outro tipo de
dado. Aqui está um exemplo simples:

Neste exemplo, a função imprimirPessoa recebe uma struct do tipo

Pessoa como argumento e imprime os valores dos campos dessa
struct. Ao chamar a função, você passa uma instância da struct
como argumento, neste caso, pessoa1.
 103
20. Maps

Um map em Go é uma estrutura de dados que facilita a associação

de valores a chaves, proporcionando uma implementação eficiente
de tabelas de hash ou dicionários comuns em outras linguagens de
programação. Essa estrutura consiste em uma coleção dinâmica
de pares chave-valor, onde cada chave é única dentro do map e
está vinculada a um valor específico.

Os maps em Go são dinâmicos, permitindo a adição, remoção e

atualização de pares chave-valor durante a execução do programa.
Além disso, os tipos de dados das chaves e dos valores podem
variar, proporcionando flexibilidade na manipulação de diferentes
tipos de informações.

O acesso aos valores associados a uma chave é efetuado de

forma rápida e direta, proporcionando um acesso eficiente aos
dados armazenados. Além disso, é possível verificar a existência
de uma chave no map utilizando a atribuição múltipla, como em
valor, chaveExiste := meuMapa["chave"].

Em resumo, os maps são uma ferramenta poderosa em Go,

oferecendo uma maneira flexível e eficiente de organizar e
manipular dados associados, sendo particularmente úteis em
situações onde é necessário indexar e recuperar valores com base
em chaves únicas.

Veja a sintaxe básica para criar um map, tanto com var quanto com
o “:=”:
 104

Este exemplo mostra como criar mapas em Go:

No map a, as chaves são strings representando informações sobre

um carro (marca, modelo e ano), e os valores associados a essas
chaves são também strings.
No map b, as chaves são strings representando estados
brasileiros, e os valores associados a essas chaves são inteiros
representando algum tipo de identificador.
As linhas fmt.Printf são utilizadas para imprimir os maps
formatados. %v é um indicador de formato que exibe os valores de
uma forma padrão. No contexto do código, isso imprimirá os maps
a e b na saída padrão. O uso de tabs (\t) na string de formato ajuda
a alinhar a saída para melhor legibilidade.

Importante: A ordem dos elementos do mapa definidos no código é

diferente da forma como são armazenados. Os dados são
armazenados de forma que haja uma recuperação eficiente dos
dados do mapa.
 105
Criando Mapas usando a Função make():

É possível criar mapas com a função make(). Veja a sintaxe:

Agora, veja um exemplo de um mapa usando a função make():

 106
Criando um Mapa Vazio:
Existem duas maneiras de criar um mapa vazio. Uma é usando a
função make() e a outra é usando a seguinte sintaxe:

Importante: A função make() é a maneira correta de criar um mapa

vazio. Se você criar um mapa vazio de uma maneira diferente e
escrever nele, isso causará pânico no tempo de execução.

Este exemplo mostra a diferença entre declarar um mapa vazio

usando com a função make() e sem ela:

A palavra-chave nil em Go é utilizada para representar a ausência

de valor ou a falta de inicialização de um ponteiro, slice, map,
channel, ou interface.
Neste caso, nil está relacionada à verificação de inicialização dos
mapas. Entenda:
 107
var a = make(map[string]string): o mapa (a) foi criado usando a
função make. Mesmo que o mapa esteja vazio, ele é inicializado
internamente, apontando para uma estrutura de dados adequada.
Portanto, a não é nil.
var b map[string]string: Neste caso, uma variável (b) do tipo mapa
está sendo declarada, mas não está inicializando. Isso significa que
b é nil por padrão, pois não foi atribuído nenhum valor.

Tipos de chave permitidos:

A chave do mapa pode ser de qualquer tipo de dados para o qual o
operador de igualdade (==) esteja definido. Esses incluem:
- Booleanos;
- Números;
- Strings;
- Arrays;
- Ponteiros;
- Sructs;
- Interfaces (desde que o tipo dinâmico suporte igualdade).

Os tipos de chave inválidos são:

- Slices;
- Maps;
- Functions.

Esses tipos são inválidos porque o operador de igualdade (==) não

está definido para eles.
 108
Importante: os valores dos mapas podem ser de qualquer tipo.

Acessar Elementos do Mapa:

Para acessar elementos de um mapa em Go, você utiliza a chave
correspondente ao elemento desejado dentro de colchetes “[ ]”.
Veja um exemplo:

Atualizar e Adicionar Elementos a um Mapa:

É possível atualizar e adicionar elementos num mapa, veja:
 109
Remover Elementos de um Mapa:
A remoção de elementos de um mapa é feita usando a função
delete().Veja como é a sintaxe:

Exemplo:
 110
Verificando Elementos Específicos em um Mapa:
Você pode verificar se uma determinada chave existe em um mapa
usando:

Se você deseja apenas verificar a existência de uma determinada

chave, pode usar o identificador em branco ( _ ) no lugar de val.
Veja o exemplo:

Neste exemplo, verificamos a existência de diferentes chaves no

mapa.
A chave “cor” não existe no mapa. Portanto, o valor é uma string
vazia (“”).
A variável ok2 é usada para descobrir se a chave existe ou não.
Porque teríamos obtido o mesmo valor se o valor da chave “color”
estivesse vazio. Este é o caso de val3.
 111
Conclusão e Agradecimento

Embora essa introdução tenha fornecido uma base sólida para

entender o básico da linguagem Go, é importante destacar que o
universo dessa linguagem é vasto e cheio de recursos
interessantes. Esta breve exploração é apenas o ponto de partida.

Incentivo a todos a continuarem aprofundando seus

conhecimentos, explorando temas mais avançados e buscando por
mais recursos disponíveis. A jornada no aprendizado de Go é uma
oportunidade para se aprimorar continuamente. Há sempre mais
para descobrir e aprender, então não se limitem a este ebook.
Explorem, pratiquem e expandam suas habilidades em Go!

Agradeço ao meu Mestre, que sempre esteve apoiando as minhas

decisões desde o princípio.