Como escrever pacotes Go

Um pacote Go consiste em arquivos Go localizados no mesmo diretório, no início dos quais existe a mesma expressão de package . Pacotes que se conectam a programas permitem expandir seus recursos. Alguns pacotes fazem parte da biblioteca Go padrão. Isso significa que, se você usar o Go, eles já estarão instalados. Outros pacotes são instalados usando o comando go get . Você também pode escrever seus próprios pacotes Go, criando arquivos em diretórios especiais e aderindo às regras de design de pacotes.



O material, cuja tradução publicamos hoje, é um guia para o desenvolvimento de pacotes Go que podem ser conectados a outros arquivos.

Pré-requisitos

• Configure o seu ambiente de software Go (saiba como fazer isso aqui ). Crie uma área de trabalho Ir (o quinto ponto do material acima é dedicado a isso). Na próxima seção deste material, você encontrará exemplos que são recomendados para serem reproduzidos em casa. Então você pode lidar melhor com eles.
• Para aprofundar o seu conhecimento da GOPATH - dê uma olhada neste material.

Escrevendo e importando pacotes

Escrever código de pacote é o mesmo que escrever código Go normal. Os pacotes podem conter declarações de funções, tipos e variáveis, que podem ser usados ​​em outros programas Go.

Antes de começarmos a criar um novo pacote, precisamos ir para o espaço de trabalho Ir. Está localizado no caminho especificado pela variável GOPATH . Por exemplo, deixe nossa organização ser chamada de gopherguides . Ao mesmo tempo, nós, como repositório, usamos o GitHub . Isso leva ao fato de que, ao longo do caminho especificado por GOPATH , temos a seguinte estrutura de pastas:

 └── $GOPATH    └── src        └── github.com            └── gopherguides 

Vamos nomear o pacote que iremos desenvolver neste guia, greet . Para fazer isso, crie o diretório greet no diretório gopherguides . Como resultado, a estrutura de pastas existente assumirá o seguinte formato:

 └── $GOPATH    └── src        └── github.com            └── gopherguides                └── greet 

Agora estamos prontos para adicionar o primeiro arquivo ao diretório greet . Normalmente, um arquivo que é o ponto de entrada de um pacote é chamado da mesma maneira que o diretório do pacote. Nesse caso, isso significa que nós, no diretório greet , criamos o arquivo greet.go :

 └── $GOPATH    └── src        └── github.com            └── gopherguides                └── greet                    └── greet.go 

Nesse arquivo, podemos escrever o código que queremos reutilizar em nossos projetos. Nesse caso, criaremos a função Hello , que exibe o texto Hello, World! .

Abra o arquivo greet.go em um editor de texto e adicione o seguinte código:

 package greet import "fmt" func Hello() {    fmt.Println("Hello, World!") } 

Vamos analisar o conteúdo deste arquivo. A primeira linha de cada arquivo deve conter o nome do pacote em que trabalhamos. Como estamos no package greet , a palavra-chave package é usada aqui, seguida pelo nome do pacote:

 package greet 

Isso diz ao compilador para aceitar tudo no arquivo como parte do pacote greet .

Em seguida, os pacotes necessários são importados usando a instrução de import . Nesse caso, precisamos apenas de um pacote - fmt :

 import "fmt" 

E, finalmente, criamos a função Hello . Ela usará os recursos do pacote fmt para exibir a sequência Hello, World! :

 func Hello() {    fmt.Println("Hello, World!") } 

Agora, após a criação do pacote greet , você pode usá-lo em qualquer outro pacote. Vamos criar um novo pacote no qual usaremos o pacote greet .

Nomeadamente, criaremos um pacote de example . Para fazer isso, procederemos das mesmas suposições das quais procedemos, criando o pacote greet . Primeiro, crie a pasta de example na pasta gopherguides :

 └── $GOPATH    └── src        └── github.com            └── gopherguides                    └── example 

Agora crie um arquivo que é o ponto de entrada do pacote. Consideramos esse pacote como um programa executável, e não como um pacote cujo código está planejado para ser usado em outros pacotes. Os arquivos que são os pontos de entrada dos programas geralmente são chamados main.go :

 └── $GOPATH    └── src        └── github.com            └── gopherguides                └── example                    └── main.go 

Abra o arquivo main.go no editor e main.go código main.go seguir, o que permite tirar proveito do pacote greet :

 package main import "github.com/gopherguides/greet" func main() {    greet.Hello() } 

Nós importamos o pacote greet no arquivo main.go , o que significa que, para chamar a função declarada neste pacote, precisamos usar a notação de ponto. Uma notação de ponto é uma construção na qual um ponto é colocado entre o nome do pacote e o nome do recurso deste pacote a ser usado. Por exemplo, no pacote greet , a função Hello desempenha o papel de um recurso. Se você precisar chamar essa função, a notação de ponto será usada : greet.Hello() .

Agora você pode abrir o terminal e executar o programa:

 go run main.go 

Depois de fazer isso, o terminal exibirá o seguinte:

 Hello, World! 

Agora vamos falar sobre como usar variáveis ​​declaradas em pacotes. Para fazer isso, adicione a declaração da variável ao arquivo greet.go :

 package greet import "fmt" var Shark = "Sammy" func Hello() {    fmt.Println("Hello, World!") } 

Abra o arquivo main.go e adicione uma linha onde a função fmt.Println() é usada para exibir o valor da variável Shark declarada no pacote greet.go . Ou seja, traga main.go para o seguinte formato:

 package main import (    "fmt"    "github.com/gopherguides/greet" ) func main() {    greet.Hello()    fmt.Println(greet.Shark) } 

Execute o programa novamente:

 go run main.go 

Agora ela exibirá o seguinte:

 Hello, World! Sammy 

Agora vamos falar sobre como declarar tipos em pacotes. Crie um tipo de Octopus com os campos Name e Color e crie um método de tipo. Este método, quando chamado, retornará o conteúdo especialmente processado dos campos Octopus . Vamos greet.go para o seguinte formulário:

 package greet import "fmt" var Shark = "Sammy" type Octopus struct {    Name string    Color string } func (o Octopus) String() string {    return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color) } func Hello() {    fmt.Println("Hello, World!") } 

Agora abra o main.go , crie uma instância da estrutura do novo tipo e consulte o método String() :

 package main import (    "fmt"    "github.com/gopherguides/greet" ) func main() {    greet.Hello()    fmt.Println(greet.Shark)    oct := greet.Octopus{        Name: "Jesse",        Color: "orange",    }    fmt.Println(oct.String()) } 

Depois de criar uma instância do Octopus usando uma construção parecida com oct := greet.Octopus , você pode acessar os métodos e propriedades do tipo no main.go para main.go arquivo main.go Isso, em particular, permite que você use o comando oct.String() localizado no final do arquivo main.go sem recorrer ao greet . Além disso, podemos, por exemplo, consultar o campo da estrutura Color usando a construção oct.Color . Ao mesmo tempo, nós, como quando chamamos o método, não acessamos greet .

O método String do tipo Octopus usa a função fmt.Sprintf para formar a sentença e retorna, usando return , o resultado, a string, para a chamada do método (nesse caso, este local está em main.go ).

Execute o programa novamente:

 go run main.go 

Ele produzirá o seguinte para o console:

 Hello, World! Sammy The octopus's name is "Jesse" and is the color orange. 

Agora que equipamos o Octopus com o método String , temos um mecanismo de saída de informações de tipo adequado para reutilização. Se, no futuro, você precisar alterar o comportamento desse método, que pode ser usado em muitos projetos, será suficiente editar seu código em greet.go .

Exportação de Entidades

Você deve ter notado que tudo com que trabalhamos ao acessar o pacote greet tem nomes que começam com uma letra maiúscula. O Go não possui modificadores de acesso, como public , private ou protected , que estão em outros idiomas. A visibilidade das entidades para mecanismos externos é controlada pelo fato de com que letra, com uma letra pequena ou grande, começam seus nomes. Como resultado, tipos, variáveis, funções cujos nomes começam com uma letra maiúscula estão disponíveis fora do pacote atual. O código visível fora do pacote é chamado de exportado.

Se você equipar o tipo Octopus com um novo método chamado reset , esse método poderá ser chamado no pacote greet , mas não no arquivo main.go , que está fora do pacote greet . Aqui está uma versão atualizada do greet.go :

 package greet import "fmt" var Shark = "Sammy" type Octopus struct {    Name string    Color string } func (o Octopus) String() string {    return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color) } func (o Octopus) reset() {    o.Name = ""    o.Color = "" } func Hello() {    fmt.Println("Hello, World!") } 

Vamos tentar chamar reset do arquivo main.go :

 package main import (    "fmt"    "github.com/gopherguides/greet" ) func main() {    greet.Hello()    fmt.Println(greet.Shark)    oct := greet.Octopus{        Name: "Jesse",        Color: "orange",    }    fmt.Println(oct.String())    oct.reset() } 

Isso resultará no seguinte erro de compilação:

 oct.reset undefined (cannot refer to unexported field or method greet.Octopus.reset) 

Para exportar o método de reset tipo Octopus , é necessário renomeá-lo, substituindo a primeira letra minúscula r por maiúscula R Fazemos isso editando greet.go :

 package greet import "fmt" var Shark = "Sammy" type Octopus struct {    Name string    Color string } func (o Octopus) String() string {    return fmt.Sprintf("The octopus's name is %q and is the color %s.", o.Name, o.Color) } func (o Octopus) Reset() {    o.Name = ""    o.Color = "" } func Hello() {    fmt.Println("Hello, World!") } 

Isso levará ao fato de que poderemos chamar Reset de outros pacotes e sem encontrar mensagens de erro:

 package main import (    "fmt"    "github.com/gopherguides/greet" ) func main() {    greet.Hello()    fmt.Println(greet.Shark)    oct := greet.Octopus{        Name: "Jesse",        Color: "orange",    }    fmt.Println(oct.String())    oct.Reset()    fmt.Println(oct.String()) } 

Execute o programa:

 go run main.go 

Aqui está o que chega ao console:

 Hello, World! Sammy The octopus's name is "Jesse" and is the color orange The octopus's name is "" and is the color . 

Ao chamar o método Reset , limpamos os campos Name e Color da nossa instância Octopus . Como resultado, ao chamar String , onde o conteúdo dos campos Name e Color foram exibidos anteriormente, agora nada é exibido.

Sumário

Escrever pacotes Go não é diferente de escrever código Go normal. No entanto, colocar o código do pacote em seus próprios diretórios permite isolar o código, que pode ser usado em qualquer outro projeto Go. Aqui conversamos sobre como declarar funções, variáveis ​​e tipos em pacotes, examinamos como usar essas entidades fora dos pacotes e descobrimos onde armazenar pacotes projetados para reutilização.

Caros leitores! Quais programas você costuma escrever no Go? Você usa pacotes proprietários neles?