Go (também conhecido como Golang) é uma linguagem de programação de código aberto e estaticamente tipada. Foi originalmente desenvolvida pelo Google. Algumas características notáveis do Go incluem simplicidade, alto desempenho, legibilidade e eficiência.
Como qualquer outra linguagem de programação proeminente, a biblioteca padrão do Go oferece um rico conjunto de pacotes. No entanto, também podemos estender as funcionalidades incorporando pacotes de terceiros. Este guia irá demonstrar como importar pacotes e incorporá-los em seus projetos Go.
Pré-requisitos
Para seguir este guia, você precisará dos seguintes componentes preparados à sua disposição:
- Um servidor Ubuntu configurado corretamente. Saiba mais sobre configurar o seu próprio servidor Ubuntu na CloudSigma.
- O ambiente de programação Go. Você pode usar este guia sobre instalar o Go no Ubuntu.
- Um editor de texto moderno, por exemplo, Vim, Sublime Text, Atom, Visual Studio Code, Brackets, etc. Este guia apresentará o Visual Studio Code .
Passo 1 – Instalando o Go
Nós já discutimos a instalação do núcleo da linguagem de programação Go no Ubuntu 20.04. No entanto, existe um método alternativo mais fácil: g (um gerenciador de versões do Go leve).
A razão pela qual vamos usar o g é que nenhuma das versões do Go disponíveis nos repositórios de pacotes do Ubuntu ou snap apresenta a versão mais recente do Go disponível (v1.18 no momento da redação deste guia). É sempre recomendado usar a versão mais recente disponível de qualquer pacote de linguagem de programação.
O seguinte comando executará o g script de instalação:
|
1 |
wget -qO- https://git.io/g-install | sh -s |
Para que as alterações entrem em vigor, você deve reiniciar a sessão do shell. Após reiniciar, verifique a instalação:
|
1 |
go version |
|
1 |
which go |
Após instalar o Go, também é recomendado instalar o gopls . É o servidor de linguagem oficial do Go. É compatível com muitos editores de texto como VS Code, Vim, Emacs, Sublime Text, Atom e muito mais. Execute o seguinte comando:
|
1 |
go install golang.org/x/tools/gopls@latest |
Nosso ambiente de programação Go está pronto.
Passo 2 – Criando um Script Go de Exemplo
Todos os códigos demonstrados neste guia caberão em um único script Go. Crie um script Go de exemplo:
|
1 |
touch practice.go |
Depois de fazer alterações no script, podemos executá-lo usando o seguinte comando Go:
|
1 |
go run practice.go |
Aqui, o compilador Go executará o código no modo interpretador.
Passo 3 – Usando Pacotes da Biblioteca Padrão
O Go vem com uma enorme coleção em sua biblioteca padrão. Ela consiste em inúmeros pacotes, por exemplo:
- fmt: Implementa E/S formatada com funções análogas ao C ( printf e scanf ).
- http: Este pacote fornece funções para criar serviços web, enviar e recuperar dados através do http protocolo, etc.
Para incorporar qualquer pacote em um projeto Go, ele deve ser implementado usando a import instrução. A instrução é declarada pela import palavra-chave junto com os nomes dos pacotes. For exemplo, para importar math/rand , a instrução de importação seria assim:
|
1 |
import "math/rand" |
O código a seguir implementa várias funções do pacote math/rand :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package main import "math/rand" func main() { for i := 0; i < 10; i++ { println(rand.Intn(25)) } } |
Este código demonstra um loop for simples que imprime 10 números inteiros aleatórios (0 a 24) na tela. Aqui:
- rand.Int() : Esta chamada de função retorna um número inteiro aleatório.
- rand.Intn() : Age de forma semelhante ao rand.Int() mas aceita um parâmetro que define o intervalo para números inteiros aleatórios (de 0 ao número especificado).
Em seguida, execute o código:
|
1 |
go run practice.go |
A saída será parecida com esta:
Observe que a saída será exatamente a mesma, pois a semente para o gerador de números aleatórios é um valor fixo por padrão. Esta é a natureza de um gerador de números pseudoaleatórios. Você pode aprender mais sobre semente aleatória aqui.
Passo 4 – Importando Múltiplos Pacotes
Projetos maiores e mais complexos precisam incorporar múltiplos pacotes. Como você os importa para o seu código Go? Uma opção válida é usar instruções de importação individuais para cada pacote importado. No entanto, essa abordagem é ineficiente em comparação com a seguinte estrutura de importação:
|
1 2 3 4 5 6 7 8 9 |
import ( "<package_1>" "<package_2>" "<package_3>" ) |
Aqui, uma única instrução de importação incorpora múltiplos pacotes ao mesmo tempo. Isso reduz a quantidade de código necessária para escrever, ao mesmo tempo que melhora a legibilidade.
O seguinte código coloca esse recurso em ação:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package main import ( "fmt" "math/rand" ) func main() { for i := 0; i < 10; i++ { fmt.Printf("%d) %d\n", i, rand.Intn(25)) } } |
Execute o código:
|
1 |
go run practice.go |
A saída será parecida com isto:
Passo 5 – Instalando Bibliotecas Go Adicionais
A biblioteca padrão do Go vem com inúmeros pacotes úteis. Eles são, por design, de uso geral. Isso permite que os desenvolvedores criem seus próprios pacotes sobre a biblioteca padrão para atender às suas necessidades específicas. Confira o oficial banco de dados de pacotes Go.
E se você precisar implementar um pacote Go de terceiros? O Go vem com o go install comando ( go get está descontinuado). Ele pode obter qualquer pacote Go de terceiros da internet.
Para demonstração, nós vamos instalar o cobra-cli pacote. O seguinte comando Go fará o download e instalará os arquivos necessários e integrará o pacote ao sistema de bibliotecas do Go:
|
1 |
go install github.com/spf13/cobra-cli@latest |
O binário do cobra-cli deve estar localizado no seguinte local:
|
1 |
ls -l $GOPATH/bin |
Os outros arquivos do pacote devem estar localizados no seguinte local:
|
1 |
ls -l $GOPATH/pkg/mod/github.com/spf13 |
A partir do Go v1.11, os módulos Go definem a versão do pacote que você deseja importar. Isso é explicado em detalhes aqui: Go Modules GitHub.
Passo 6 – Aliases de Pacotes
Em várias situações, você pode encontrar nomes de pacotes conflitantes entre os pacotes locais e os importados. É aqui que a criação de aliases pode resolver a colisão. A estrutura de alias se parece com isto:
|
1 |
import <alias> "import_package_name" |
Vamos modificar nosso programa Go simples para incorporar fmt_alias como um alias para o pacote fmt :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package main import ( fmt_alias "fmt" "math/rand" ) func main() { for i := 0; i < 10; i++ { fmt_alias.Printf("%d) %d\n", i, rand.Intn(25)) } } |
Observe que, em vez de usar fmt.Printf() , nós estamos usando o alias do pacote fmt_alias.Printf() .
No entanto, o Go não é tão receptivo a aliases. Quando você estiver usando aliases para evitar colisão de nomes de importação, é recomendado criar um alias para a importação mais local ou específica do projeto. Por exemplo, se você quiser ter tanto um pacote local strings e um pacote do sistema strings , então você deve criar um alias para o pacote local, não para o pacote do sistema.
A melhor prática é evitar colisões de nomes em primeiro lugar.
Passo 7 – Formatação de Importações
Aprendemos a declarar todas as importações usando uma única instrução import . E se você tivesse várias importações? Por exemplo:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import ( "fmt" "os" "github.com/example/foo" "github.com/example/bar" "math/rand" "github.com/abc/pqr/xyz" ) |
A formatação de imports ordena os pacotes em uma ordem específica, melhorando a consistência do código. Como apenas ordena a ordem dos imports, também evita commits aleatórios. Também evita alterações desnecessárias de código e revisões de código confusas.
A maioria dos editores modernos formatará os imports para você automaticamente. Alternativamente, eles suportarão goimports. É uma prática comum na indústria usar goimports em vez de ordenar manualmente os imports. Além disso, goimports também reflete mudanças de estilo no código.
Aqui está a aparência do bloco de import após a aplicação do goimports :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
import ( fmt_alias "fmt" "math/rand" "os" "github.com/example/foo" "github.com/example/bar" "github.com/abc/pqr/xyz" ) |
Notou algum padrão?
- Todas as bibliotecas padrão são agrupadas primeiro.
- Os grupos são separados por linhas em branco, melhorando a legibilidade do código.
Considerações Finais
Imports no Go são um recurso poderoso que permite chamar funções não integradas ao Go. Embora a biblioteca padrão ofereça muitos pacotes de uso geral, o Go também suporta pacotes de terceiros. Este guia demonstra como importar pacotes integrados e de terceiros do Go.
Neste guia, executamos nossos programas Go usando o interpretador. No entanto, você pode compilar os códigos em binários autônomos para obter um melhor desempenho. Você pode aprender mais sobre como compilar programas Go aqui. Se você quiser aprender como implantar uma aplicação web Go com o Nginx, confira este tutorial. Além disso, você pode dar uma olhada no nosso guia que mostra como escrever seus próprios pacotes Go.
Você é um desenvolvedor Go? A CloudSigma oferece suporte à API Go para uma integração perfeita com seus projetos.
Boa computação!
Comentários
Nenhum comentário ainda. Seja o primeiro.