Golang: como usar pacotes de biblioteca

A maioria das linguagens de programação vem com bibliotecas integradas. Com essas bibliotecas, você pode usar código pré-construído que atenda a uma finalidade específica. Ao fazer isso, você não apenas precisa escrever menos código, mas também pode ter certeza de que o código importado dessas bibliotecas sempre fará exatamente o que você espera.

Sem bibliotecas, seu código não seria apenas consideravelmente mais longo, mas também muito mais complicado.

Por exemplo, você tem a biblioteca padrão Go, que adiciona vários pacotes importantes para funcionalidades essenciais. Você encontrará fmt (para E/S formatada), erros (implementa funções para manipulação de erros), criptografia (para coletar constantes criptográficas comuns) e muito mais. Você pode ver toda a Biblioteca Padrão aqui.

Mas se você estivesse limitado à Biblioteca Padrão, não conseguiria fazer muita coisa. Você estaria limitado a usar o que estava disponível ou a escrever seu próprio código para a funcionalidade necessária.

É por isso que você precisa saber como importar pacotes de bibliotecas com Go.

Um problema circular crescente com a importação de pacotes

Antes de entrarmos nisso, quero abordar algo que encontrei em algumas ocasiões. Que algo está obsoleto obter comando, que você encontrará em tutoriais, instruções e até mesmo em livros didáticos em todos os lugares. O obter O comando foi descontinuado quando os módulos foram introduzidos. Quando isso aconteceu, o obter O comando estava sendo usado para atualizar dependências em um arquivo go.mod e também para instalar comandos, o que era confuso.

Mas, se você visualizar determinados pacotes no GitHub (como o driver MySQL), ainda encontrará a lista de instruções conforme o procedimento, como vá buscar -u github.com/go-sql-driver/mysql, o que não funciona. E se você tentar usar o substituto para instalar, receberá um erro como:

Tente instalar github.com/go-sql-driver/mysql@latest‘para instalar a versão mais recente

Vamos tentar essa sugestão. Correr:

vá instalar github.com/go-sql-driver/mysql@latest

Adivinha? Isso também ocorre com:

package github.com/go-sql-driver/mysql is not a main package

É um problema circular.

Isso começou porque eu queria escrever um tutorial sobre como conectar o Go a um banco de dados MariaDB. O que deveria ser simples se transformou em um pesadelo recursivo, simplesmente porque não consegui instalar o driver MySQL para Go. Então, criei o banco de dados e tentei importar o driver sem sucesso.

Então tentei carregar o driver de dentro do código, que era mais ou menos assim:

package main

import (
    "database/sql"
    "fmt"
    "log"
    "os"

    "github.com/go-sql-driver/mysql"
)

Depois de completar todo o bloco de código (que se conecta ao meu banco de dados, executo o comando:

go mod init github.com/go-sql-driver/mysql

Isso é seguido por:

está muito arrumado

Agora tenho um arquivo go.mod que inclui:

module github.com/go-sql-driver/mysql

go 1.22.1

Tudo deve funcionar bem. Isso não acontece. Só para você ter uma ideia de como é o código completo (que foi inspirado na documentação oficial do Golang aqui), dê uma olhada:

package main

import (
    "database/sql"
    "fmt"
    "log"
    "os"
)

var db *sql.DB

func main() {
    // Capture connection properties.
    cfg := mysql.Config{
        User:   os.Getenv("ubooks"),
        Passwd: os.Getenv("PASSWORD"),
        Net:    "tcp",
        Addr:   "192.168.1.166:3306",
        DBName: "books",
    }

    // Get a database handle.
    var err error
    db, err = sql.Open("mysql", cfg.FormatDSN())
    if err != nil {
        log.Fatal(err)
    }

    pingErr := db.Ping()
    if pingErr != nil {
        log.Fatal(pingErr)
    }
    fmt.Println("Connected!")
}

Agora, quando executo o aplicativo, recebo o seguinte erro:

./main.go:17:12: undefined: mysql

Lembre-se, isso é da documentação oficial. Depois de fazer uma pesquisa considerável, descobri que o tutorial na documentação falha sem AllowNativePasswords: verdadeiro.

Adivinha? Ele falha mesmo com a afirmação acima. O problema é óbvio, temos que definir o mysql antes de podermos chamá-lo com o mysql. Então encontrei outro método, que falhou comigo.

Claramente, esta é uma questão complexa.

Escusado será dizer que tive que desistir disso por enquanto. Voltarei a isso assim que descobrir o problema.

Então, por enquanto, evitaremos importar pacotes de terceiros (falaremos disso mais tarde, depois que eu tiver resolvido o problema do MySQL – porque usar bancos de dados em aplicações é realmente muito importante.

Uma biblioteca Golang para números aleatórios

Digamos que você queira um código Go que imprima 10 números aleatórios entre 1 e 1000. Para isso, você precisa importar o pacote match, que inclui a função rand.

Se você está acompanhando, já sabe que precisa adicionar o pacote main no topo do seu código para funcionar como um ponto de entrada e que o pacote deve ser compilado como um programa executável e não como uma biblioteca compartilhada.

Depois disso, podemos importar nosso pacote e especificar a função que queremos usar:

import "math/rand"

Agora criaremos uma função que imprimirá 10 números aleatórios entre 0 e 1000, usando um loop for básico. É assim:

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

Todo o bloco de código se parece com isto:

package main

import "math/rand"

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

Quando você executa o procedimento acima, a saída pode ser semelhante a esta:

452
853
822
346
461
729
672
513
158
481

O problema com isso é que não é muito aleatório. Para tornar a aleatoriedade ainda mais confiável, precisamos semeá-la com alguma coisa. Existe um pacote para isso, chamado time, que inclui tudo o que precisamos para propagar um número aleatório com o tempo, especificamente, o horário atual.

Para isso, precisamos mudar nossa função, para definir agora assim:

now := time.Now()

Há também uma função chamada UnixNano() isso produz t como um tempo Unix que é o número de segundos passados ​​desde 1º de janeiro de 1970. Implementamos isso da seguinte forma:

rand.Seed(now.UnixNano())

Toda a nossa função agora se parece com isto:

func main() {
now := time.Now()
rand.Seed(now.UnixNano())
println("Random numbers seeded with Unix Time: ", now.UnixNano())
for i := 0; i < 5; i++ {

Nosso aplicativo inteiro é assim:

package main

import (
       "math/rand"
       "time"
)

func main() {
        now := time.Now()
        rand.Seed(now.UnixNano())
println("Random numbers seeded with Unix Time: ", now.UnixNano())
        for i := 0; i < 5; i++ {
                 println(rand.Intn(10))

            }
}

Quando executamos o procedimento acima, obtemos algo assim como saída:

Números aleatórios propagados com Unix Time: 1713204758111329492
3
5
4
5
1
9
1
7
3
1

Agora, esses são números verdadeiramente aleatórios.

E é assim, meus novatos em Golang, que usamos pacotes de biblioteca em Go.

A postagem Golang: como usar pacotes de biblioteca apareceu pela primeira vez em The New Stack.