Pacote local de importação de Golang

Em Go, um pacote refere -se a uma coleção de arquivos de código -fonte Go no mesmo diretório que são compilados juntos. Normalmente, você usará esses pacotes para exportar e importar código entre eles. Isso, por sua vez, torna o código modular e fácil de manter.

No entanto, se você está apenas entrando na linguagem de programação Go, pode ser bastante difícil descobrir como importar pacote local. É disso que trata este tutorial.

Pacote de Golang

Para entender melhor o que é um pacote Go, vamos pegar um projeto chamado meu espaço de trabalho. Dentro do diretório da área de trabalho, você tem mais 3 diretórios chamados DIR1, DIR2 e DIR3.

Portanto, a árvore do diretório é como mostrado:

└───Workspace
├───DIR1
├───Dir2
└───Dir3

Isso significa que o projeto do espaço de trabalho tem 3 pacotes. Cada arquivo criado em cada diretório se torna parte desse pacote (diretório).

Lembre -se de que o projeto principal é o que é conhecido como o pacote principal. Na maioria dos casos, você encontrará arquivos como principal.vá com a primeira linha de código como ”

Pacote principal

Voltando ao projeto da área de trabalho, você fará a primeira entrada em cada um dos arquivos com o nome do pacote sob o qual eles pertencem.

Um exemplo é como:

pacote dir1 // para arquivos em dir1
pacote dir2 // para arquivos no dir2
pacote dir3 // para dir3

Cada arquivo dentro de um pacote pode exportar seu código. Outros arquivos dentro do projeto podem fazer referência a esse pacote (diretório) e importar o código dos arquivos. Isso permite que você importe apenas um único pacote e todo o código nos arquivos sob esse pacote estará acessível para uso.

Para criar um novo pacote em seu projeto, você pode simplesmente criar um novo diretório.

Vejamos um exemplo prático para criar pacotes Go Go.

Golang Módulo inicialize

A primeira etapa quando os pacotes de importação é inicializar um novo módulo. Você pode fazer isso executando o comando:

vá mod init

Por exemplo, no diretório da área de trabalho, podemos criar um novo módulo como:

Vá Mod Init Workspace

Depois de executar o Mod Init, ele cria uma chance.arquivo mod que acompanha os módulos que você importa. O arquivo também contém informações como o nome do módulo, a versão Go, etc.

Pense nisso como o pacote.arquivo json no nó.

Lembre -se da nomeação de seus módulos, conforme você exigirá ao importar seus pacotes. Um exemplo de go.O arquivo mod é como mostrado:

Espaço de trabalho do módulo
vá 1.17

Como não temos pacotes externos, o arquivo contém o nome do módulo e a versão Go.

Golang Create Package

Como mencionado, para criar um pacote em seu projeto Go, crie um novo diretório e adicione os arquivos de código -fonte sob esse pacote.

Por exemplo, vamos criar arquivos de origem Go Go para pacotes DIR1, DIR2 e DIR3.

$ touch dir1/dir1.ir
$ touch dir2/dir12.ir
$ touch dir3/dir3.ir

Na primeira linha de cada arquivo, inclua o espaço para nome do pacote como:

Pacote Dir1 // Substitua Dir2 pelo nome do pacote

Em seguida, vamos adicionar algum código em cada um desses arquivos.

// dir1.ir
pacote dir1
funcsayhello () string
Retorne "Oi do pacote dir1"

// dir2.ir
pacote dir2
funcsayrunning () string
Retorne "estou fugindo do pacote dir2"

// DIR3.ir
pacote dir3
funcsaybye () string
Retorne "Adeus do pacote dir3"

Os exemplos acima são simples. São apenas funções que retornam um valor de string de cada pacote.

NOTA: Para exportar uma variável ou uma função de um pacote Go, verifique se você inicia o nome da função ou variável com uma letra de alta.

Novamente: ☝️☝️☝️☝️☝️

Golang Importar pacotes locais

O último passo é importar seus pacotes locais para que você possa usar o código em cada um deles. Na raiz do seu projeto, aka, o diretório da área de trabalho, crie um principal.vá arquivo.

Em seguida, adicione as seguintes linhas para importar seus pacotes locais:

Pacote principal
importação (
"FMT"
"Espaço de trabalho/dir1"
"Espaço de trabalho/dir2"
"Espaço de trabalho/dir3"
)
funcmain ()
fmt.Println (dir1.Diga olá())
fmt.Println (dir2.SayRunning ())
fmt.Println (dir3.Diga tchau())

No exemplo acima, adicionamos 3 cláusulas de importação para importar todos os pacotes em nosso programa.

Uma vez importado, podemos usar o código exportado nos pacotes.

Podemos então executar o código em Main.Vá arquivo como:

$ go run main.ir
Oi do pacote dir1
Estou fugindo do pacote dir2
Adeus do pacote dir3

Você verá a saída conforme exportado pelas funções dos pacotes.

Conclusão

Neste artigo, discutimos como você pode exportar e importar código usando pacotes Go. Os pacotes são uma maneira muito prática e limpa de organizar seu código e reter legibilidade e manutenção. Esperamos que você tenha gostado!