Base de Conhecimento

Introdução

Haverá momentos em que seu código precisará de funcionalidade adicional fora do seu programa atual. Nesses casos, você pode usar pacotes para tornar seu programa mais sofisticado. Um pacote representa todos os arquivos em um único diretório no disco. Pacotes podem definir funções, tipos e interfaces que você pode referenciar em outros arquivos ou pacotes Go.

Este tutorial orientará você na instalação, importação e alias de pacotes.

Pacotes de biblioteca padrão

A biblioteca padrão que acompanha o Go é um conjunto de pacotes. Esses pacotes contêm muitos dos blocos de construção fundamentais para escrever software moderno. Por exemplo, o fmtpacote contém funções básicas para formatação e impressão de strings. O net/httppacote contém funções que permitem que um desenvolvedor crie serviços da Web, envie e recupere dados pelo httpprotocolo e muito mais.

Para fazer uso das funções em um pacote, você precisa acessar o pacote com uma importinstrução Uma importdeclaração é composta da importpalavra - chave junto com o nome do pacote.

Como exemplo, no arquivo de programa Go, random.govocê pode importar o math/randpacote para gerar números aleatórios desta maneira:

import "math/rand"

Quando importamos um pacote, o disponibilizamos em nosso programa atual como um espaço para nome separado. Isso significa que teremos que nos referir à função na notação de ponto , como em .package.function

Na prática, uma função do math/randpacote pode se parecer com estes exemplos:

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

Vamos criar um forloop para mostrar como chamaremos uma função do math/randpacote dentro do nosso random.goprograma:

package main

import "math/rand"

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

Este programa importa primeiro o math/randpacote na terceira linha e depois move-se para um forloop que será executado 10 vezes. Dentro do loop, o programa imprimirá um número inteiro aleatório dentro do intervalo de 0até 25. O número inteiro 25é passado rand.Intn()como seu parâmetro.

Quando executamos o programa go run random.go, receberemos 10 números inteiros aleatórios como saída. Por serem aleatórios, é provável que você obtenha números inteiros diferentes sempre que executar o programa. A saída será mais ou menos assim:

6
12
22
9
6
18
0
15
6
0

Os números inteiros nunca ficarão abaixo de 0 ou acima de 24.

Ao importar mais de um pacote, você pode usar o ()para criar um bloco. Ao usar um bloco, você pode evitar repetir a importpalavra-chave em todas as linhas. Isso fará com que seu código pareça mais limpo:

import (
  "fmt"
  "math/rand"
)

Para usar o pacote adicional, agora podemos formatar a saída e imprimir a iteração na qual 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 executamos nosso programa, receberemos uma saída parecida com esta:

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

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

Instalando pacotes

Enquanto a biblioteca padrão é fornecida com muitos pacotes excelentes e úteis, eles são intencionalmente projetados para serem de uso geral e não específicos por natureza. Isso permite que os desenvolvedores criem seus próprios pacotes no topo da biblioteca padrão para suas próprias necessidades específicas.

A cadeia de ferramentas Ir é enviada com o go getcomando Este comando permite instalar pacotes de terceiros em seu ambiente de desenvolvimento local e usá-los em seu programa.

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

• go get github.com/gobuffalo/flect

A go getferramenta encontrará o pacote, no GitHub, neste caso, e o instalará no seu $GOPATH.

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

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

Os pacotes são frequentemente atualizados pelos autores originais para corrigir bugs ou adicionar novos recursos. Quando isso acontece, convém usar a versão mais recente desse pacote para aproveitar os novos recursos ou o bug resolvido. Para atualizar um pacote, você pode usar o -usinalizador com o go getcomando:

• go get -u github.com/gobuffalo/flect

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

O go getcomando sempre recupera a versão mais recente do pacote disponível. No entanto, pode haver atualizações para as versões anteriores do pacote ainda mais recentes do que você está usando e que seriam úteis para atualizar no seu programa. Para recuperar essa versão específica do pacote, você precisaria usar uma ferramenta de Gerenciamento de Pacotes , como os Módulos Go .

No Go 1.11, os Go Go são usados ​​para gerenciar a versão do pacote que você deseja importar. O tópico de gerenciamento de pacotes está além do escopo deste artigo, mas você pode ler mais sobre ele na página GitHub do Go Modules .

Aliasing de pacotes importados

Você pode alterar um nome de pacote se já tiver um pacote local com o mesmo nome de um pacote de terceiros que estiver usando. Quando isso acontece, criar alias na importação é a melhor maneira de lidar com a colisão. Você pode modificar os nomes dos pacotes e suas funções no Go, colocando um aliasnome na frente do pacote importado.

A construção desta declaração é assim:

import another_name "package"

Neste exemplo, modifique o nome do fmtpacote no random.goarquivo de programa. Alteraremos o nome do pacote de fmtpara fpara abreviá-lo. Nosso programa modificado ficará assim:

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 à Printffunção em f.Printfvez de fmt.Printf.

Enquanto outros idiomas favorecem o aliasing de um pacote para facilitar o uso posteriormente no programa, o Go não. Por exemplo, o alias do fmtpacote fnão seria consistente com o guia de estilo .

Ao renomear importações para evitar uma colisão de nomes, você deve renomear a importação mais local ou específica do projeto. Por exemplo, se você tiver chamado um pacote localstrings e também precisar importar o pacote do sistemastrings , é preferível renomear o pacote local em vez do pacote do sistema. Sempre que possível, é melhor evitar a colisão de nomes completamente.

Nesta seção, aprendemos como podemos alias uma importação para evitar colidir com outra importação em nosso programa. É importante lembrar que a legibilidade e a clareza do seu programa são importantes; portanto, você só deve usar o alias para tornar o código mais legível ou quando precisar evitar uma colisão de nomes.

Formatação de importações

Ao formatar as importações, você pode classificar os pacotes em uma ordem específica que tornará seu código mais consistente. Além disso, isso impedirá que confirmações aleatórias ocorram quando a única coisa que muda é a ordem de classificação das importações. Como a formatação de importações impedirá confirmações aleatórias, isso evitará a rotatividade desnecessária de códigos e revisões de código confusas.

A maioria dos editores formatará as importações automaticamente ou permitirá que você configure seu editor para uso goimports. É considerado uma prática padrão usar goimportsno seu editor, pois tentar manter manualmente a ordem de classificação de suas importações pode ser entediante e propenso a erros. Além disso, se houver alguma alteração no estilo, goimportsela será atualizada para refletir essas alterações. Isso garante que você e qualquer pessoa que trabalhe no seu código tenha um estilo consistente nos seus blocos de importação.

Aqui está a aparência de um exemplo de bloco de importação antes da formatação:

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

Ao executar a goimportferramenta (ou com a maioria dos editores que a instalou, salvar o arquivo executará para você), agora você terá o seguinte formato:

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

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

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

Observe que ele agrupa todos os pacotes de biblioteca padrão primeiro e, em seguida, agrupa pacotes de terceiros com linhas em branco. Isso facilita a leitura e a compreensão de quais pacotes estão sendo usados.

Nesta seção, aprendemos que o uso goimportsmanterá todos os nossos blocos de importação formatados corretamente e evitará a rotatividade desnecessária de código entre os desenvolvedores que trabalham nos mesmos arquivos.

Conclusão

Quando importamos pacotes, podemos chamar funções que não estão embutidas no Go. Alguns pacotes fazem parte da biblioteca padrão que instala com o Go, e alguns serão instalados através dele go get.

O uso de pacotes nos permite tornar nossos programas mais robustos e poderosos, pois estamos aproveitando o código existente. Também podemos criar nossos próprios pacotes para nós mesmos e para outros programadores usarem em programas futuros.