Importando pacotes em Go

Introdução

Haverá ocasiões em que o seu código irá precisar de funcionalidades adicionais, fora do seu programa atual. Nesses casos, utilize pacotes para tornar seu programa mais sofisticado. Um pacote representa todos os arquivos em um único diretório em disco. Os pacotes podem definir funções, tipos e interfaces que você pode referenciar em outros arquivos ou pacotes em Go.

Este tutorial irá explicar sobre como instalar, importar e gerar pacotes de alias.

Pacotes da biblioteca padrão

A biblioteca padrão que vem com o Go é um conjunto de pacotes. Esses pacotes contêm muitos dos blocos de compilação essenciais para escrever softwares modernos. Por exemplo, o pacote fmt contém funções básicas para a formatação e impressão de strings. O pacote net/http contém funções que permitem que um desenvolvedor crie serviços para a Web, envie e recupere dados através do protocolo http, entre outros.

Para usar as funções em um pacote, você precisa acessar o pacote com uma instrução import. Uma instrução import é composta pela palavra-chave import junto com o nome do pacote.

Como exemplo, no arquivo do programa Go random.go você pode importar o pacote math/rand para gerar números aleatórios desta maneira:

import "math/rand"

Quando importamos um pacote, nós o disponibilizamos em nosso programa atual como um namespace separado. Isso significa que teremos que nos referir à função em notação de ponto, como em package.function.

Na prática, uma função do pacote math/rand poderia se parecer com estes exemplos:

• rand.Int() que chama a função para retornar uma número inteiro aleatório.
• rand.Intn() que chama a função para retornar um elemento aleatório de 0 até o número especificado fornecido.

Vamos criar um loop for para mostrar como chamaremos uma função do pacote math/rand dentro de nosso programa random.go:

package main

import "math/rand"

func main() {
  for i := 0; i < 10; i++ {
    println(rand.Intn(25))
  }
}

Esse programa importa primeiro o pacote math/rand na terceira linha e, depois, inicia um loop for que será executado 10 vezes. Dentro do loop, o programa imprimirá um número inteiro aleatório no intervalo de 0 a 25. O inteiro 25 é enviado para o rand.Intn() como seu parâmetro.

Quando executamos o programa com go run random.go, receberemos 10 inteiros aleatórios como resultado. Como eles são aleatórios, é provável que você receba diferentes números inteiros sempre que executar o programa. O resultado se parecerá com este:

Output
6
12
22
9
6
18
0
15
6
0

Os inteiros nunca serão menores que 0 ou maiores que 24.

Ao importar mais de um pacote, utilize o () para criar um bloco. Ao usar um bloco, você pode evitar a repetição da palavra-chave import a cada linha. Isso dará uma aparência mais limpa ao seu código:

import (
  "fmt"
  "math/rand"
)

Para usar o pacote adicional, podemos agora formatar o resultado e imprimir a iteração em que cada número aleatório foi gerado durante o loop:

package main

import (
  "fmt"
  "math/rand"
)

func main() {
  for i := 0; i < 10; i++ {
    fmt.Printf("%d) %d\n", i, rand.Intn(25))
  }
}

Agora, quando executarmos nosso programa, receberemos um resultado que se parece com este:

Output
0) 6
1) 12
2) 22
3) 9
4) 6
5) 18
6) 0
7) 15
8) 6
9) 0

Nesta seção, aprendemos a importar pacotes e usá-los para escrever um programa mais sofisticado. Até agora, usamos apenas pacotes da biblioteca padrão. Em seguida, vamos ver como instalar e usar pacotes que são escritos por outros desenvolvedores.

Instalando pacotes

Embora a biblioteca padrão venha com muitos pacotes notáveis e úteis, eles foram intencionalmente concebidos para ser de propósito geral e não específico, em natureza. Isso permite que os desenvolvedores compilem seus próprios pacotes além da biblioteca padrão para suas próprias necessidades específicas.

A cadeia de ferramentas em Go vem com o comando go get. Esse comando permite que você instale pacotes de terceiros em seu ambiente de desenvolvimento local e os utilize em seu programa.

Ao usar o go get para instalar pacotes de terceiros, é comum que um pacote seja referenciado através de seu caminho canônico. Esse caminho também pode ser o caminho de um projeto público hospedado em um repositório de códigos como o GitHub. Como tal, se quisesse importar o pacote flect, você usaria o caminho canônico completo:

go get github.com/gobuffalo/flect

A ferramenta go get irá encontrar o pacote - neste caso, no GitHub - e irá instalá-lo em seu $GOPATH.

Neste exemplo, o código seria instalado neste diretório:

$GOPATH/src/github.com/gobuffalo/flect

Os pacotes frequentemente são atualizados pelos autores originais para corrigir bugs ou adicionar novos recursos. Quando isso acontece, você pode querer usar a versão mais recente daquele pacote para se beneficiar de novos recursos ou de bugs já solucionados. Para atualizar um pacote, você pode usar um sinalizador -u com o comando go get:

go get -u github.com/gobuffalo/flect

Esse comando também fará o Go instalar o pacote se ele não for encontrado localmente. Se ele já estiver instalado, o Go tentará atualizar o pacote para a versão mais recente.

O comando go get sempre recupera a versão mais recente do pacote disponível. No entanto, pode haver atualizações para as versões anteriores do pacote, que são ainda mais atuais do que a que você está usando - e seria útil atualizá-las em seu programa. Para recuperar essa versão específica do pacote, você precisaria usar uma ferramenta de Gerenciamento de Pacotes, como a Go Modules.

A partir da versão Go 1.11, os Go Modules são usados para gerenciar qual versão do pacote você quer importar. O tema de gerenciamento de pacotes está além do âmbito deste artigo, mas você pode ler mais a respeito na página Go Modules do GitHub.

Gerando aliases de pacotes importados

Talvez você queira alterar o nome de um pacote, caso você já estiver usando localmente um pacote com o mesmo nome do pacote do terceiro. Quando isso acontece, gerar um alias para a sua importação é a melhor maneira de lidar com esse conflito. Você pode modificar os nomes dos pacotes e suas funções dentro de Go, colocando um alias [pseudônimo] na frente do nome do pacote importado.

A construção dessa instrução se parece com esta:

import another_name "package"

Neste exemplo, modifique o nome do pacote fmt no arquivo do programa random.go. Vamos alterar o nome do pacote de fmt para f para abreviá-lo. Nosso programa modificado se parecerá com este:

package main

import (
 f "fmt"
  "math/rand"
)

func main() {
  for i := 0; i < 10; i++ {
    f.Printf("%d) %d\n", i, rand.Intn(25))
  }
}

Dentro do programa, agora nos referimos à função Printf como f.Printf em vez de fmt.Printf.

Embora outras linguagens favoreçam a geração de aliases para os pacotes, facilitando sua utilização posterior no programa, a linguagem Go não age assim. Por exemplo, a criação de alias f para o pacote fmt não seria consistente com o guia de estilos.

Ao renomear importações para evitar conflito de nomes, você deve procurar renomear a importação mais local ou específica do projeto. Por exemplo, se tivesse um pacote local chamado strings e você também precisasse importar o pacote* sistema* igualmente chamado strings, você escolheria renomear o seu pacote local e não o pacote do sistema. Sempre que possível, é melhor evitar, de um modo geral, o conflito entre nomes.

Nesta seção, aprendemos como podemos gerar um alias para uma importação para evitar que coincida com outra importação em nosso programa. É importante lembrar que a legibilidade e a clareza do seu programa é importante e, portanto, você deve apenas gerar aliases para tornar o código mais legível ou precisar evitar um conflito entre nomes.

Formatando as importações

Ao formatar as importações, você pode classificar os pacotes em uma ordem específica que tornará o seu código mais consistente. Além disso, isso impedirá que confirmações aleatórias aconteçam quando a única coisa que mudar for a ordem de classificação das importações. Como a formatação impedirá confirmações aleatórias, isso evitará as análises desnecessárias da variação e confusão dos códigos.

A maioria dos editores formatará as importações para você automaticamente, ou permitirá que você configure seu editor para usar o goimports. O uso do goimports no editor é prática considerada padrão, uma vez que as tentativas de se manter manualmente a ordem de classificação das importações podem provar-se tediosas e propensas a erros. Além disso, caso qualquer alteração de estilo seja feita, o goimports será atualizado para refletir essa alteração. Isso garante que você e qualquer um que trabalhe em seu código, aplicará estilos de modo consistente em seus blocos de importação.

A seguir, apresentamos um exemplo da aparência que um bloco de importação tem antes da formatação:

import (
  "fmt"
  "os"
  "github.com/digital/ocean/godo"
  "github.com/sammy/foo"
  "math/rand"
  "github.com/sammy/bar"
)

Executando a ferramenta goimport (ou com a maioria dos editores que a tiver instalada, salvar o arquivo executará a ferramenta para você) você terá, então, o seguinte formato:

import (
  "fmt"
  "math/rand"
  "os"

  "github.com/sammy/foo"
  "github.com/sammy/bar"

  "github.com/digital/ocean/godo"
)

Observe que ela agrupa todos os pacotes da biblioteca padrão primeiro e então agrupa pacotes de terceiros juntos, com linhas em branco. Isso torna mais fácil ler e entender quais pacotes estão sendo usados.

Nesta seção, aprendemos que usar o goimports manterá todos os nossos blocos importados devidamente formatados e evitará a variação desnecessária do código entre os desenvolvedores que trabalhem nos mesmos arquivos.

Conclusão

Quando importamos pacotes, conseguimos chamar funções que não são implícitas para a linguagem Go. Alguns pacotes fazem parte da biblioteca padrão que vem instalada com o Go e alguns deles nós instalaremos através do go get.

Fazer uso de pacotes nos permite tornar nossos programas mais robustos e poderosos, já que estamos potencializando o código existente. Também podemos criar nossos próprios pacotes para usu próprio e para que outros programadores possam usá-los em programas futuros.