Importe e use um pacote de terceiros em Golang

Como a maioria das linguagens de programação compiladas, a linguagem de programação Go possibilita o uso de bibliotecas externas e outras ferramentas pré-empacotadas.

Por exemplo, com o testado e comprovado aplicativo Hello World, chamamos o principal pacote e importe o pacote fmt assim:

package main

import "fmt"

func main() {
    fmt.Println("Hello, New Stack")
}

Sem a capacidade de chamar esses pacotes, você teria que escrever cada linha de código, o que complicaria enormemente o processo. Esse simples aplicativo de cinco linhas poderia, de repente, se transformar em um aplicativo de cem linhas.

Dado que o objetivo é trabalhar de maneira mais inteligente e não mais difícil, você faz não quero ter que lidar com toda essa programação extra – especialmente porque já foi feita. E, no caso de principal e fmteles são integrados ao aplicativo Golang.

Prático.

O principal O pacote é especial porque é usado para tornar um programa executável. Ao usar main, você informa ao compilador Go que o programa deve ser compilado como um executável e não como uma biblioteca.

O fmt O pacote é importante porque permite a formatação de strings e valores básicos de forma que possam ser impressos na saída padrão, coletar a entrada do usuário no console ou gravar a entrada em um arquivo.

Há uma grande variedade de pacotes possíveis que podem ser usados ​​para Golang. Você pode ir para o Ferramenta de pesquisa de pacotes Golang e pesquise no repositório de pacotes. Digamos, por exemplo, que você queira escrever um aplicativo Go que imprima uma citação aleatória e concisa. Você pode pensar que isso seria um desafio, mas como já existe um pacote para isso, você não precisa se preocupar em codificar tudo para o aplicativo.

O que você precisa cuidar antes de compilar seu aplicativo com êxito é adicionar o pacote de terceiros. Felizmente, isso não é um grande desafio – você só precisa saber como isso é feito.

Deixe-me te mostrar.

Primeiro, deixe-me mostrar o aplicativo que iremos executar. Crie um novo arquivo .go com o comando:

<span style="font-weight: 400;">nano quote.go</span>

Nesse arquivo, cole o seguinte:

package main

import "fmt"

import "rsc.io/quote"

func main() {
 fmt.Println("Your pithy quote of the day is:n")
 fmt.Println(quote.Go())

}

Depois de compilado, o aplicativo acima imprimirá a linha:

Não comunique compartilhando memória, compartilhe memória comunicando.

Se você tentasse compilar o acima sem primeiro adicionar o pacote de cotação, receberia um erro.

Como você contorna isso? Primeiro você precisa inicializar o pacote de cotação, o que é feito com o comando:

<span style="font-weight: 400;">go mod init quote</span>

Depois de fazer isso, você pode baixar o pacote com:

<span style="font-weight: 400;">go mod tidy</span>

Agora, compile seu aplicativo com:

<span style="font-weight: 400;">go build quote.go</span>

Isso criará um executável chamado chamar. Execute o aplicativo com:

<span style="font-weight: 400;">./quote</span>

Você verá a saída que listei acima.

Vamos um pouco mais fundo.

O que vamos fazer agora é criar nosso próprio módulo e depois chamá-lo a partir de uma aplicação.

Primeiro, crie uma nova estrutura de diretórios com o comando:

<span style="font-weight: 400;">mkdir -p projects/mymodule</span>

Mude para o diretório de módulos com:

<span style="font-weight: 400;">cd projects/mymodule</span>

Inicialize os módulos com:

<span style="font-weight: 400;">go mod init mymodule</span>

Você encontrará um novo ir.mod arquivo foi adicionado.

A seguir, crie um principal.go arquivo com:

<span style="font-weight: 400;">nano main.go</span>

Nesse arquivo, cole o seguinte código:

package main

import "fmt"

func main() {
fmt.Println("Hello, New Stack!")
}

Bem direto.

Salve e feche o arquivo.

Agora você pode testar o código inicial com:

<span style="font-weight: 400;">go run main.go</span>

Você deverá ver a seguinte saída:

Olá, Nova Pilha!

Ótimo.

Agora, vamos criar um novo pacote que chamaremos do nosso principal.go arquivo. Ainda assim, no diretório mymodule, crie um novo diretório com:

<span style="font-weight: 400;">mkdir mypackage</span>

Crie um novo arquivo .go com:

<span style="font-weight: 400;">nano mypackage/mypackage.go</span>

Nesse arquivo, cole o seguinte:

package newpackage

import "fmt"

func NSHello() {
             fmt.Println("Hello, New Stack! You've just called your first module!")
}

Como você pode ver, criamos uma função chamada NSHello() que imprime a linha “Hello, New Stack!” Você acabou de chamar seu primeiro módulo!

Salve e feche o arquivo.

Em seguida, precisamos chamar nosso novo pacote no arquivo main.go. Abra esse arquivo para edição com o comando:

<span style="font-weight: 400;">nano /main.go</span>

Atualmente, o arquivo está assim:

package main

import "fmt"

func main() {
        fmt.Println("Hello, New Stack!")
}

O que precisamos fazer é importar o novo pacote que acabamos de criar. Primeiro, altere a seção de importação para:

import (
       "fmt"
       "mymodule/mypackage"
)

Em seguida, altere a seção func main() para ficar assim:

func main() {
        fmt.Println("Hello, New Stack!")

        mypackage.NSHello()
}

O que fizemos neste arquivo foi importar nosso novo pacote (com a linha meu módulo/meu pacote) e então usá-lo em conjunto com nosso NSHello() função que definimos em meupacote.go.

O arquivo inteiro fica assim:

package main

import (
       "fmt"
       "mymodule/mypackage"
)

func main() {
        fmt.Println("Hello, New Stack!")

        mypackage.PrintHello()
}

Salve e feche o arquivo.

Execute todo o aplicativo com:

<span style="font-weight: 400;">go run main.go</span>

A saída deve ser:

Olá, Nova Pilha!
Olá, Nova Pilha! Você acabou de chamar seu primeiro módulo!

Ou você pode construir um executável com o comando:

<span style="font-weight: 400;">go build main.go</span>

E esta é a sua introdução à chamada de pacotes externos em Golang.

A postagem Importar e usar um pacote de terceiros em Golang apareceu pela primeira vez em The New Stack.