Aula 01
Módulos de Golang / Go: Como São Definidos
Summary
# Resumo da Aula sobre Módulos em Go
Nesta aula, o instrutor discutiu os módulos da linguagem de programação Go, incluindo como definir e usar módulos no código fonte.
## Introdução aos Módulos de Go
- **Biblioteca Padrão**: Go possui uma biblioteca padrão que inclui vários pacotes, como `FMT` e `strings`.
- **Pacotes de Terceiros**: Além da biblioteca padrão, existem pacotes criados por terceiros, que são agrupados em módulos.
## Importação de Módulos
- Módulos podem ser importados no código Go com a palavra-chave `import`.
- Eles são geralmente armazenados em repositórios de controle de versão, como o GitHub.
## Exemplo de Módulo: GorillaMux
- O GorillaMux é um exemplo de módulo para gerenciamento de rotas em servidores web.
- O repositório contém o arquivo `go.mod`, que define o caminho do módulo e a versão mínima do Go requerida.
### Estrutura de um Módulo
- O arquivo `go.mod` contém:
- A especificação do módulo com a palavra-chave `module`.
- A versão mínima do Go necessária.
- Dependências do módulo, se existirem.
- Exemplos de pacotes em um módulo:
- O GorillaMux tem um único pacote, enquanto o Go Ethereum possui múltiplos pacotes (`Core`, `GraphQL`).
## Dependências de Módulos
- Dependências podem ser diretas ou indiretas.
- O Go utiliza um sistema de versionamento semântico, que organiza as versões em maior, menor e patch.
### Arquivo `go.sum`
- Um arquivo `go.sum` é gerado automaticamente para garantir que as versões das dependências sejam consistentes entre diferentes desenvolvedores.
## Conclusão
- O Go permite a criação descentralizada de módulos.
- Nele, todas as dependências são compiladas no executável final, eliminando a necessidade de vinculação externa.
- Módulos em Go são definidos com um arquivo `go.mod`, que contém informações essenciais sobre o módulo e suas dependências.
A aula termina com a recomendação de criar repositórios com um arquivo `go.mod` para facilitar o uso e importação de pacotes na linguagem Go.
Video Transcript
Olá pessoal, esta aula vou falar sobre módulos de Go, falar de como o módulo de Go é definido
no código fonte.
Vamos começar aqui na página oficial da linguagem.
Eu cliquei em packages, pacotes e temos aqui a standard library, a biblioteca padrão
da linguagem de Go lang.
Temos vários módulos aqui, na biblioteca padrão, por exemplo, o famoso FMT está aqui,
certo?
Esse pacote FMT, cadê os strings?
Tem os strings e assim por diante.
Então, esses pacotes todos aqui são a biblioteca padrão, mas é claro que a gente só não
usa pacotes da biblioteca padrão, a gente usa pacotes escritos por outras pessoas, por
terceiros, né?
Então, pacotes de terceira pessoa também existem.
Então, no mundo do Go, esses pacotes são aglomerados em o que se chama módulo de Go.
E esse módulo pode ser importado através do palavra chave import, né?
No código fonte.
Agora, esses módulos são armazenados dentro de um repositório, né?
De controle de versão.
Popularmente, hoje em dia, é usando o get, né?
Então, vamos aqui a um exemplo.
Você já usou GorillaMux?
Deixa eu clicar na nova aba aqui.
Eu estou na parte aqui do gethug, do GorillaMux, tá?
Então, GorillaMux é um módulo de Go, tá?
E esse módulo aqui é para... tem dizendo aqui sobre o que é.
A ajuda a você fazer as rotas, né?
Você tem um servidor web de Go.
Para definição...
Puteador, HTTP, Zipoadjunt, Matur, não sei o que.
Então, esse é um módulo de terceiros, né?
Não é WB, até que é padrão.
E você pode usar esse módulo no seu projeto.
Então, nós temos aqui o código fonte, né?
E é...
Está encapsulado nesse repositor de geth e está hospedado no gethug.
Então, esse é um módulo, tá?
E o módulo pode ter vários pacotes.
Nesse caso aqui do Mux, ele é bem simples.
Eu acho que só tem um pacote.
Se você ver no código fonte aqui, por exemplo, mox.go,
e olha na linha package, né?
Que tem a Java package.
Tem o pacote mox.
E se eu olhar em outro route, mox.go, também pacote mox.
Então, esse módulo é bem simples, por isso, parece que só tem um pacote chamado mox,
que é o mesmo nome do caminho desse módulo.
Mas pode ter vários pacotes.
A gente vai ver no outro exemplo ali.
Então, o que define um repositório como um projeto de Go?
O arquivo go.mode, tá?
Tem que ter esse arquivo go.mode.
O arquivo go.mode, você tem a palavra-chave-módulo,
que vai definir o caminho desse módulo.
Normalmente, vai ser o site de hospedagem,
barra o caminho do repositório.
Nesse caso, get-file.com.bar-gurilla-mox,
que corresponde ao RL aqui em cima, se você ver no navegador.
Tem também a linha pra você definir a versão mínima do Go.
Nesse caso, esse módulo vai funcionar com a versão 1.2 e acima.
Do Go.
Tem também outras linhas que definem as dependências
se o projeto tiver dependência.
Mas como esse módulo de Go.mode, que é bem simples,
ele não depende em nenhum outro projeto de terceiros.
Então, esse é o exemplo bem simples de um módulo de Go.
E pra poder usar isso, é só dar um importe
pra ver esse caminho em um string lá na hora de importe.
Agora, vamos olhar outro exemplo aqui.
Eu vou em outro repositório do Go Ethereum.
Na Go Ethereum, implementação do protocolo de Ethereum
na linguagem Go.
Cryptomoeda, esse negócio.
Então, Go Ethereum aqui, você nota que já tem
muito mais arquivos do que o Go.mux.
Esse olhar aqui, por exemplo,
Core, Blockchain, esse pacote chamado Core.
Package Core, já temos um pacote chamado Core.
Vamos olhar em outro aqui, deixou lá,
pasta GraphQL.
Já vê o package GraphQL, pacote GraphQL.
Então, já tem dois pacotes diferentes no mesmo módulo.
Como eu disse antes, o módulo de Go,
que por si só é mais ou menos um repositório,
pode ter vários pacotes, tem um coletano de pacotes.
E note também que o nome do pacote
não precisa ser o nome,
mesmo o nome do módulo em si.
O nome desse módulo é Go Ethereum.
A gente vai ver aqui como definido no GoMod.
Então, vamos lá, GoMod,
arquivo GoMod, define o nome do módulo aqui,
o caminho, que ele avanto com a barra Ethereum,
barra Go Ethereum.
E define na linha 3,
e define na linha 3,
a versão, esse vai funcionar a partir da versão 1.15 do Go.
Note aqui que o módulo Go Ethereum
depende também em vários outros módulos de Go.
Então, ele define na linha 5 aqui,
chama Require, né?
Abre parênteses aqui, depois de espaço,
e a lista cada um,
lixo de dependências cada um em uma linha.
E não se esqueça de fechar com fecha parêntese no final.
Então, vamos ver a primeira linha aqui.
Ele depende do pacote, gethub.com.barragem, barragem, pipeline Go.
E espaço, a versão,
tenta mesmo comentar aqui que esse negócio aqui,
significa que esse módulo,
módulo é uma dependência indireta, isso é.
Quando você depende de uma outra biblioteca,
ou outro projeto,
essa é uma dependência direta.
Mas se aquele projeto em que você depende,
também depende em outro projeto,
aquele outro projeto é uma dependência indireta,
porque você não referencia ele diretamente.
Isto é, é uma dependência da sua dependência.
Então, às vezes, o Go precisa também incluir
a dependência indireta no seu GoMod.
Então, às vezes vai aparecer esse negócio aqui.
Então, isso indica que esse aqui
não é uma dependência direta,
é indireta, mas,
por alguma razão,
tivemos que incluir no seu GoMod.
Então, prosseguindo aqui,
o próximo depende também do módulo
Azure Storage, lobby Go,
que está nos casos de pedaços de gethub,
nessa conta, Azure.
E a versão especificada aqui,
espaço, versão V0.7.0.
Note que a versão especificada
segue um padrão chamado
Semantic Virginie, sem V,
tá?
Vessionamento semmático.
Por isso que é sempre o mesmo padrão de 3
números separados por um ponto.
No número mais à esquerda,
significa a versão maior, major.
No número do meio, é a versão menor, minor.
E o número mais à direita,
é a versão de patch, né?
Que é feita quando você conserta bugs.
Então, a versão de patch
mais à direita quando você conserta o bug,
você incrementa.
Se você adicionar alguma nova
funcionalidade no programa,
mas que não quebre a compatibilidade,
é uma versão menor que a incrementada.
Se você adicionar alguma coisa que
quebra a compatibilidade com a versão anterior,
tem que incrementar a versão maior,
que é o número mais à esquerda,
e zerar todos os números do meio e da direita.
Tá?
Então é isso.
Então, você note que a maioria dessas dependências
está hospedadas no GitHub.com,
mas tem também algumas que estão em outros
sites, né?
Golang.org, barra, x, barra, crypto.
Golpkg.in, barra, native, barra,
n5.v2.
E assim por diante.
Norte que tem também a...
é possível também especificar
a versão aqui no nome
do caminho final do pacote.
E depois,
certas versões aqui
têm esse número meio esquisito, porque
é o que se chama
piseu do versão que foi
adicionada pelo Gol.
Talvez não tenha esse
golang.org, barra, x, barra, time.
Ele não tenha especificado
uma tag de versão corretamente no seu repositor,
ou algo aconteceu que ele não pôde
identificar que versão é, então Golang
criou essas piseu do versão.
Tá bom?
Então é isso, né?
Então note que
para você ter um... definir
um...
Ah, eu também esqueci de uma coisa aqui.
Quando você tem várias dependências,
vai também ser criado o arquivo
Gol.sum.
Esse Gol.sum é um arquivo de que vai...
vai mostrar que vai incluir
todas as versões dos
módulos que foram usados no seu projeto.
Isso é para poder identificar
quando você
baixar o repositor e
obter as dependências e compilar
quando ele fizer isso tudo, que ele vai sempre usar
a mesma versão que as outras pessoas
usaram, né?
Então esse arquivo também é parte
do repositor e você deve
checar na sua versão de...
controle de versão, caso o Get.
Fazer o check-out, né?
É, então ele mostra várias versões
também do...
mesmo pacote, isso é normal.
Aí mostra esse check.sum,
que ele check os conteúdos, né?
Para ver se não tem
alguma mudança.
Sei lá se vai ver
a versão que você usou,
alguma mudança foi feita no código,
alguma coisa aconteceu, então pode dar problema.
Ou você estava...
Você estava usando esse código dessa maneira
e de repente mudou o conteúdo,
aí vai dar problema, né?
Para aquela versão. Então ele tem
esses check-sums aqui que ele vai
identificar e tal e tem as versões
e por diante.
Então esse que você...
É, também chamar de
lockfire, por exemplo,
você já usou o NPM
com JavaScript,
packagelock.json, similar, né?
Esses tipos de arquivos.
Então, para concluir,
você note que
pacote de terceiros,
módulos, né? De terceiros,
que o módulo pode ter
vários pacotes e o módulo
é hospedado em um repositório
e pode ser qualquer site.
Você note que tem uma descentralização
no gênese amete
de pacotes do Go.
Não tem, assim,
em geral, não tem uma
central aonde
você chama para obter
os pacotes, como por exemplo
no caso de
NPM no JavaScript, que você dá
o NPM em install, ele vai
obter os pacotes da central
do site do NPM.
Não é bem assim no Go. No Go
é mais descentralizado, né?
Então você pode
só... Qualquer
um pode definir um módulo de Go.
Basta ter
algum lugar, né? Alguns sites, como
GitHub.com
e você cria um repositório
e você
tem um arquivo Go.mode
e basta você ter aquele caminho, né?
É, normalmente, GitHub.com
barra o
nome da conta, barra
o nome do repositório
e aquele caminho que você define
no seu Go.mode
e
você usa aquele caminho
nos seus impostos do seu próprio
projeto. E o Go
vai automaticamente
procurar
por aquele repositório
e vai baixar e vai incluir
no seu projeto, né?
E é...
E no Go, quando você
compila, ele já compila tudo
no
mesmo executável,
ele vai botar todas as dependências lá,
incluir todas as dependências.
Não tem esse negócio de
por exemplo, você
vai... Você tem uma
biblioteca que é escrita,
que já está instalada no seu sistema
e você vai
de alguma maneira linkar para poder
usar o
código compilado da biblioteca que está em outro lugar.
Não é assim, ele já inclui
todas as dependências do programa
e o Go depende, ele já inclui
no seu executável.
Isso também significa se você tiver dois
programas
diferentes que incluem
a mesma dependência, cada
programa vai ter sua própria
vamos se dizer
própria conteúdo
com
a questão compilada daquele
módulo de terceiros, né? Então...
Termo de espaço
seria ocupar o mesmo
espaço dobrado.
Essas coisas sim, mas
isso para um negócio
funcionar sem problemas, né?
De alguma
maneira, então, para concluir é só isso.
A gente aprendeu
tem a
biblioteca padão do Go
e tem pacotes terceiros
e qualquer pessoa pode
criar, só criar o repositor.
Tem aquele arquivo Go
Mod, né?
Define
o caminho do módulo, versão
do Go e as dependências
com Require
e você tiver várias dependências
ele vai criar também o Go.sum
que também deve ser incluído
no seu repositor
e vai verificar lá
e
deixar tudo se assim
alguma outra pessoa baixar o repositor
do seu projeto, ele vai instalar a mesma
versão que os outros
desenvolvedores.
Tá bom? Então, por essa aula
é só e eu te vejo na próxima.
Nenhum comentário ainda (loading...)
Nenhum comentário ainda (loading...)
Gostou da aula? 😆👍
Apoie nosso trabalho com uma doação: