Forem: ionnss

Scrapper Concorrente

ionnss — Tue, 05 Nov 2024 14:35:52 +0000

Objetivo do programa

Acessar páginas web ao mesmo tempo para extrair o título de cada página e exibir esses títulos no terminal. Isso é feito utilizando concorrência em Go, que permite acessar várias páginas simultâneamente, economizando tempo.

Explicação do Código

Pacotes utilizados

import (
    "fmt"
    "net/http"
    "sync"
    "github.com/PuerkitoBio/goquery"
)

Função `fetchTitle`

Essa função é reponsável por:

Acessar uma página web (url)
Extrair o título da página
Evniar o resultado para um canal

func fetchTitle(url string, wg *sync.WaitGroup, results chan<- string) {
    defer wg.Done() // Marca a goroutine como concluída no WaitGroup

Parâmetros da função:

url string: Representa o endereço da página web (url) que vamos acessar para obter o título
wg *sync.WaitGroup: Pointeiro para um WaitGroup, que usamos para sincornizar o término de todas as tarefas (goroutines) que estão rodando ao mesmo tempo. O*indica que estamos passando um "enderço" para oWaitGroup` e não uma cópia dela.
results chan<- string: Este é um canal unidirecional que permite enviar strings para outra parte do programa. Ele é usado para passar resultados (títulos ou mensagens de erro) para a função main

A linha defer wg.Done() diz ao programa para marcar esta tarefa (goroutine) como concluída quando a função fetchTitle terminar. Isso é importante para que o main saiba quando todas as tarefas foram concluídas.

Requisição HTTP

req, err := http.Get(url) if err != nil { results <- fmt.Sprintf("Erro ao acessar %s: %v", url, err) return } defer req.Body.Close()

http.Get(url): Esta linha faz um pedido HTTP GET para a URL. Isso significa que estamos acessando a página e pedindo ao servidor o conteúdo dela.
err != nil: Aqui verificamos se houve algum erro ao acessar a página (por exemplo, se a página não existe ou o servidor não está respondendo). Se houver erro, enviamos uma mensagem para o canal results e encerramos a função com return.
defer req.Body.Close(): Isso garante que, depois que terminarmos de usar o conteúdo da página, liberaremos a memória alocada para armazená-lo.

Verificação de Status

if req.StatusCode != 200 { results <- fmt.Sprintf("Erro ao acessar %s: status %d %s", url, req.StatusCode, req.Status) return }

req.StatusCode != 200: Verificamos se o servidor respondeu com o código 200 OK (indica sucesso). Se não for 200, isso significa que a página não foi carregada corretamente. Então, enviamos uma mensagem de erro para o canal results e encerramos a função.

Carregamento e Busca do Título

doc, err := goquery.NewDocumentFromReader(req.Body) if err != nil { results <- fmt.Sprintf("Erro ao carregar documento de %s: %v", url, err) return } title := doc.Find("title").Text() results <- fmt.Sprintf("Título de %s: %s", url, title) }

goquery.NewDocumentFromReader(req.Body): Carregamos o conteúdo HTML da página (fornecido por req.Body) no goquery, que permite navegar e buscar partes específicas do HTML.
doc.Find("title").Text(): Procuramos a tag <title> no HTML da página e pegamos o texto dentro dela (ou seja, o título).
results <- fmt.Sprintf("Título de %s: %s", url, title): Enviamos o título extraído para o canal results, onde ele será lido mais tarde.

Função `main`

A função main é a função principal que configura e controla o programa.

func main() { urls := []string{ "http://olos.novagne.com.br/Olos/login.aspx?logout=true", "http://sistema.novagne.com.br/novagne/", }

urls := []string{...}: Definimos uma lista de URLs que queremos processar. Cada URL será passada para uma goroutine que extrairá o título da página.

Configuração do WaitGroup e do Canal

var wg sync.WaitGroup results := make(chan string, len(urls)) // Canal para armazenar os resultados

var wg sync.WaitGroup: Criamos uma nova instância de WaitGroup, que controlará o número de goroutines e garantirá que todas terminem antes que o programa finalize.
results := make(chan string, len(urls)): Criamos um canal results com capacidade igual ao número de URLs. Esse canal armazenará as mensagens com os títulos ou erros.

Início das Goroutines

for _, url := range urls { wg.Add(1) go fetchTitle(url, &wg, results) }

for _, url := range urls: Aqui, percorremos cada URL da lista.
wg.Add(1): Para cada URL, incrementamos o contador do WaitGroup para indicar que uma nova tarefa (goroutine) será iniciada.
go fetchTitle(url, &wg, results): Chamamos fetchTitle como uma goroutine para cada URL, ou seja, fazemos com que ela rode em paralelo com as outras.

Espera e Exibição dos Resultados

wg.Wait() close(results)

REPO: https://github.com/ionnss/Scrapper-GoRoutine

ions,

mais um dia da terra

Organizador de arquivos em GO

ionnss — Tue, 29 Oct 2024 15:31:39 +0000

Olá, ions por aqui, novamente.

O medo de estar aprendendo algo que um dia uma IA irá realizar, me deixa completamente angustiado. Mas, se "resolver problemas" ainda for uma exigência impostas aos seres humanos do futuro, por que não persistir?

Desta vez trago outro tutorial. Menos inútil que o primeiro. Então vamos definir as estruturas dos "problemas", pois de uma coisa nós já sabemos: quem não tem problemas, é porque não procurou o suficiente. E quem ainda não os encontrou, é só uma questão de tempo para conseguir criá-los.

Estrutura do projeto

A estrutura mais simples do programa é:

Varrer uma pasta (por exemplo a pasta de downloads ou outro diretório)
Identificar o tipo de cada arquivo no diretório em questão
Mover o arquivo para uma subpasta correspondente ao seu tipo (imagens, videos, documentos...)

Iniciando o projeto

Crie um diretório e navegue até ele:

mkdir organizador
cd organizador

Crie um arquivo organizador.go e inicie os módulos do mesmo:

touch organizador.go
go mod init organizador.go

Você deve ter algo mais ou menos assim:

~/organizador
.
├── go.mod
└── organizador.go

Parte 1: Verificando se um diretório existe

Vamos definir o diretório de origemdirOrigem no qual realizaremos a organização. Com ele definido, vamos verificar se ele existe de fato, caso contrário, retornaremos um erro:

package main

import (
    "fmt"
    "os"
)

// Defina o deretório o qual você quer organizar como variável global
var dirOrigem string := "/Users/User/Downloads" // Troque o diretório 

func main() {

    // Verificar se o diretório existe, caso contrário, retornar erro
    if _, err := os.Stat(dirOrigem); os.IsNotExist(err) {
        fmt.Println("BAD DIR :( \nDiretório não encontrado: ", dirOrigem)
        return
    } else {
        // Imprimir mensagem caso o diretório exista
        fmt.Println("GOOD DIR :) \nDiretório encontrado: ", dirOrigem)
    }
}

Agora, vamo fazer algumas considerações a respeito do código acima:

A função os.Stat retorna dois valores do tipo os.FileInfo e erro err.

FileInfo é uma interface que retorna informações detalhadas de arquivos, que neste caso, não precisamos. Portanto, para ignorarmos essa interface, utilizamos _,. Entretanto, não queremos ignorar o erro: if _, err := ...
Passamos o erro err como parâmetro para a função os.IsNotExist(), pois se o diretório não existir, a função os.Stat() retornará um erro NÃO NULO, fazendo com que a função os.IsNotExist() retorne true, executando nossa mensagem: BAD DIR :(
Se os.IsNotExist() retornar false, teremos a impressão da mensagem da condição else: GOOD DIR :)

Parte 2: Conceito de função de "callback" é uma doidera, bixo!

Você reparou que aqui estamos indo aos poucos e nos deliciando com os bits e bytes ao som do teclado mecânico. _Tchaka tchaka bum! _

E agora nos vamos criar uma função do tipo callback. Algo que eu nunca tinha de fato aprendido sobre, ou nunca tive curiosidade o suficiente para questionar se um dia eu utilizei esse conceito em algum código python da minha vida pré-golang.

Função callback é uma função passada com argumento para outra função.

Se você já está familiarizado com o conceito, congrats, caso constrário, congrats. Ou seja, congrats!

Agora vamos criar uma função callback listarArquivos que será passada como argumento para outra função filepath.Walk.

func main() { 
// Restante do código
.
.
.

// Percorrer e listar os arquivos no diretório dirOrigem
    err := filepath.Walk(dirOrigem, listarArquivos)
    if err != nil {
        fmt.Println("Erro ao percorrer o diretório: ", err)
    }
}

// Função que lista os arquivos do diretório
func listarArquivos(caminho string, info os.FileInfo, err error) error {
    if err != nil {
        return err
    }

    // Ignorar diretórios e exibir apenas arquivos
    if !info.IsDir() && !strings.HasPrefix(info.Name(), ".") {
        fmt.Println("Arquivo encontrado: ", info.Name())
    }
    return nil
}

Mas calma, como que filepath.Walk chama a Função de Callback?

Quando você chama filepath.Walk(dirOrigem, listarArquivos), a função filepath.Walk faz o trabalho pesado de percorrer todos os arquivos e subdiretórios dentro de dirOrigem.

Para cada arquivo ou diretório encontrado, ela chama a função listarArquivos com três argumentos:

caminho: o caminho completo para o arquivo ou diretório atual.
info: um objeto os.FileInfo que contém informações sobre o arquivo/diretório (como nome, se é um diretório, tamanho, etc.).
err: um erro, caso algo dê errado ao acessar esse arquivo ou diretório.

O Go entende automaticamente que listarArquivos deve receber esses três parâmetros porque filepath.Walk espera uma função que siga exatamente essa assinatura:

// Função Walk()
func Walk(root string, walkFn WalkFunc) error

// Tipo WalkFunc
type WalkFunc func(path string, info os.FileInfo, err error) error

Repare que a função Walk retorna um error! Isso é relevante!

Por isso, que igualamos a nossa função filepath.Walk(dirOrigem, listarArquivos) a um err:

err := filepath.Walk(dirOrgiem, listarArquivos)

Pois no final das contas, por retornar um erro, ela é um erro XD

Exemplo em Ação

Aqui está uma visão mais detalhada do que acontece em cada passo:

//Percorrer e listar os arquivos no diretório
err := filepath.Walk(dirOrigem, listarArquivos)

Para cada arquivo ou diretório em dirOrigem, filepath.Walk vai chamar listarArquivos como se fosse algo assim:

listarArquivos("/Users/User/Downloads/file1.txt", infoSobreFile1, nil)
listarArquivos("/Users/User/Downloads/file2.txt", infoSobreFile2, nil)
listarArquivos("/Users/User/Downloads/file3.mp3", infoSobreFile3, nil)

Nesse exemplo, para cada chamada:

caminho: recebe o caminho do arquivo ou diretório.
info: contém informações sobre esse item (como o nome e o tipo).
err: é usado para capturar qualquer erro específico ao acessar o arquivo/diretório.

Função de Callback

A listarArquivos é uma função de callback que filepath.Walk chama automaticamente com esses valores. Assim, não precisamos nos preocupar em definir os valores de caminho, info e err; o filepath.Walk já faz isso por nós.

UFA!

Agora faça aquele teste maroto em seu terminal:

go run organizador.go

Você pode ter com resultado:

GOOD DIR :)
Diretório encontrado:  /Users/User/Downloads
Arquivo encontrado:  Suic_ SOS · 4.32pm · 10-25.jpeg
Arquivo encontrado:  Suic_ SOS.jpeg
Arquivo encontrado:  quantum-distortion-cyberpunk-music-234058.mp3
Arquivo encontrado:  slow-mode-enabled-cyberpunk-music-230623.mp3
Arquivo encontrado:  teaching-lp-20152-seminario-go.pdf

Ou:

go run organizador.go
BAD DIR :(
Diretório não encontrado:  /Users/User/Downloadss

Nesse caso eu só coloquei um "s" extra em "Downloads" para que o dirOrigem ficasse incorreto.

Agora apague a função listarArquivos, pois não vamos usá-la.

Brincadeira, só vamos mudar ela de nome e adicionar outras lógicas.

PARTE 3: ORGANIZAR != ORGANIZADO

Organizado é bom, organizar é fod@.

Depois desta constatação genial da minha parte, vamos partir para a parte que nos interessa de fato: organizar a p*rr@ toda.

Por ironia da vida, antes de organizar os arquivos, temos que organizar as idéias dos próximos passos.

Nossa próxima função precisa, basicamente:

Criar subpastas com base nas extensões de cada arquivo do nosso diretório dirOrigem, caso ela não exista.
Mover os arquivos para suas respectivas pastas de acordo com suas extensões.
Mas se os arquivos já estiverem nas subpastas organizadoras, ele não deve criá-las novamente.

Vamos entender o que cada parte desse código faz:

// Função que organiza os arquivos do diretório
func organizarArquivos(caminho string, info os.FileInfo, err error) error {
    if err != nil {
        return err
    }

    // Ignorar diretórios e exibir apenas arquivos
    if !info.IsDir() && !strings.HasPrefix(info.Name(), ".") {
        fmt.Println("Arquivo encontrado: ", info.Name())

        // Obter extensões em letras minúsculas
        extensao := strings.ToLower(filepath.Ext(info.Name()))

        // Criar nome das subpastas diretamente em dirOrigem
        subpasta := filepath.Join(dirOrigem, extensao[1:])

        // Verificar se a subpasta já existe; caso contrário, criar a pasta
        if _, err := os.Stat(subpasta); os.IsNotExist(err) {
            err := os.Mkdir(subpasta, os.ModePerm)
            if err != nil {
                fmt.Println("Erro ao criar subpasta: ", err)
                return err
            }
        }

        // Caminho de destino para mover arquivos
        caminhoDestino := filepath.Join(subpasta, info.Name())

        // Verificar se o arquivo já está na subpasta
        if caminhoDestino == caminho {
            fmt.Printf("O arquivo %s já está na subpasta %s. Ignorando...\n", info.Name(), subpasta)
        } else {
            // Mover o arquivo para a subpasta
            err := os.Rename(caminho, caminhoDestino)
            if err != nil {
                fmt.Println("Erro ao mover arquivo: ", err)
                return err
            }
            fmt.Printf("Arquivo %s movido para %s\n", info.Name(), subpasta)
        }
    }
    return nil
}

Estrutura da função organizarArquivos

A função organizarArquivos é chamada para cada arquivo ou pasta encontrada na estrutura de diretórios. Ela verifica as condições para organizar cada arquivo com base em sua extensão, criando subpastas e movendo arquivos, se necessário.

func organizarArquivos(caminho string, info os.FileInfo, err error) error {
    if err != nil {
        return err
    }

Aqui, a função organizarArquivos recebe três parâmetros:

caminho: o caminho completo para o arquivo ou diretório atual.
info: informações do arquivo ou diretório, obtidas do tipo os.FileInfo.
err: um possível erro que pode ocorrer ao tentar acessar o item.

A primeira verificação é se existe algum erro ao acessar o arquivo/diretório. Caso positivo, ele é retornado imediatamente.

Filtrando arquivos e ignorando diretórios ocultos

if !info.IsDir() && !strings.HasPrefix(info.Name(), ".") {
        fmt.Println("Arquivo encontrado: ", info.Name())

Este trecho faz duas verificações:

!info.IsDir(): verifica se o item não é um diretório (ou seja, é um arquivo).
!strings.HasPrefix(info.Name(), "."): verifica se o nome do arquivo não começa com ".", ignorando arquivos ocultos em sistemas baseados em Unix.

Se as duas condições forem atendidas, o arquivo é exibido com fmt.Println.

Identificando a extensão do arquivo e criando o nome da subpasta

extensao := strings.ToLower(filepath.Ext(info.Name()))
subpasta := filepath.Join(dirOrigem, extensao[1:])

Aqui:

strings.ToLower(filepath.Ext(info.Name())): extrai a extensão do arquivo (por exemplo, .txt) e a transforma em minúsculas para garantir consistência.
subpasta := filepath.Join(dirOrigem, extensao[1:]): cria o caminho completo da subpasta onde o arquivo será movido. O extensao[1:] remove o ponto inicial (.) da extensão, formando o nome da subpasta, como txt.

Criando a subpasta, caso ainda não exista

if _, err := os.Stat(subpasta); os.IsNotExist(err) {
            err := os.Mkdir(subpasta, os.ModePerm)
            if err != nil {
                fmt.Println("Erro ao criar subpasta: ", err)
                return err
            }
        }

Aqui, a função:

Verifica se a subpasta já existe usando os.Stat.
Se a subpasta não existe (os.IsNotExist(err)), ela é criada com os.Mkdir(subpasta, os.ModePerm).
os.ModePerm define as permissões padrão para a nova pasta. Caso haja um erro ao criar a pasta, ele é exibido e retornado.

Definindo o caminho de destino do arquivo

caminhoDestino := filepath.Join(subpasta, info.Name())

Neste ponto, caminhoDestino representa o caminho final para onde o arquivo será movido. Ele é construído usando filepath.Join, para unir o caminho da subpasta ao nome do arquivo.

Verificando se o arquivo já está na pasta de destino

if caminhoDestino == caminho {
            fmt.Printf("O arquivo %s já está na subpasta %s. Ignorando...\n", info.Name(), subpasta)
        } else {
            // Mover o arquivo para a subpasta
            err := os.Rename(caminho, caminhoDestino)
            if err != nil {
                fmt.Println("Erro ao mover arquivo: ", err)
                return err
            }
            fmt.Printf("Arquivo %s movido para %s\n", info.Name(), subpasta)
        }
    }
    return nil
}

Este trecho compara o caminhoDestino com o caminho atual do arquivo. Se forem iguais, significa que o arquivo já está na subpasta correta, então ele é ignorado com uma mensagem (fmt.Printf).
Caso contrário, os.Rename(caminho, caminhoDestino) move o arquivo para a subpasta. Se houver erro durante a movimentação, ele é retornado.

Resumo Final

A função:

Percorre um diretório, verificando cada item.
Ignora diretórios e arquivos ocultos.
Determina a extensão do arquivo e, com isso, a subpasta de destino.
Cria a subpasta (se ainda não existir).
Move o arquivo para a subpasta, a menos que ele já esteja lá.

O uso de filepath.Walk(dirOrigem, organizarArquivos) passa essa função para cada arquivo dentro do diretório, fazendo com que todos sejam organizados automaticamente.

Esse código se encaixa bem como uma função de organização de arquivos porque ele lida com a lógica de criação e movimentação em uma única função – uma forma eficiente e organizada de estrutura.

REPO: https://github.com/ionnss/organizador

***Mais um dia na terra,
ions

Nietzsche reencarnado num gato, uma "ferramente" CLI feita com GO

ionnss — Thu, 24 Oct 2024 18:28:03 +0000

Estou com três projetos de GO em mente, mas com medo de terminá-los. Quero fazer e ter a sensação de que estou aprendendo no processo, ao invés de só copiar e colar códigos de stackoverflow e chatgpt.

Eu quero dissecar os códigos, os conceitos e as ideias dos projetos para explicar em algum artigo, tipo esse. Acredito que assim eu conseguiria absorver bem o conhecimento por trás da produção dos códigos dos projetos.

Dos três projetos, nenhum se mostra ser algo muito simples. Então pensei em construir um quarto projeto, mais simples, mais curto e que eu consiga aprender alguma coisa.

Alguma coisa é melhor do que nada. E nada é melhor do que qualquer coisa inacabada.

Mas enfim, vamos nessa!

FCAT?

Ah, o nome é zuado mesmo, mas pensei no conceito de f-string, onde você introduz uma string em algum código.

Quanto ao gato... bem, aí você me pegou. As pessoas gostam de gatos. Somado a isso pensei que Nietzsche seria um gato, ao invés de um cachorro, uma borboleta, um elefante, um dinossauro ou um bicho preguiça. Então é isso. É gato, porque SIM.

Qual é o problema?

Começamos com o fato de já termos um arquivo txt com as citações do Nitzsche. O programa precisa selecionar alguma destas, de maneira aleatória e disponibilizar ao usuário. Além disso, precisa imprimir o gato em ASCII e formar um balão de diálogo em volta do quote exibido.

Resumindo:

Arquivo com as citações: arquivo .txt com citações do Nietzsche, onde cada citação esteja em uma linha separada.

Desenho de gato em ASCII: Vamos definir o desenho do gato que será impresso no terminal.

Gostei desse. Tem olhos hipnotizantes.

 ,_     _
 |\\_,-~/
 / _  _ |    ,--.
(  @  @ )   / ,-'
 \  _T_/-._( (
 /         `. \
|         _  \ |
 \ \ ,  /      |
  || |-_\__   /
 ((_/`(____,-'

Carregar e selecionar uma citação aleatória: O programa vai ler as citações de um arquivo .txt e selecionar uma aleatoriamente.

Imprimir a citação com o balão de diálogo: A citação será exibida dentro de um balão de diálogo acima do gato.

Letes go, bebê

Antes de mais nada:

Crie um diretório para o projeto e navegue até ele:

mkdir fcat
cd fcat

Crie um arquivo main.go:

touch main.go

Inicialize os módulos do go:

go mod init main.go

Seu diretório deverá estar tipo assim:

fcat
.
├── go.mod
├── main.go
└── quotes.txt

Agora abra o main.go em sua IDE de preferência.

NVIM se for do hype XD

Explicação do código:

Função `carregarCitations`

Essa função abre o arquivo de citações (nietzsche.txt), lê cada linha, e armazena todas as citações em uma lista.

A função não irá receber argumentos, apenas retornará uma lista/slice de strings e erro: string e error:

package main

import (
    "fmt"
    "os"
    "bufio" 
)

func carregarCitations()([]string, error) {
}

Dentro da função iremos inicializar um slice/lista para receber todas as citações:

package main

import (
    "fmt"
    "os"
    "bufio" 
)

func carregarCitations() ([]string, error) {

    // Abrir uma lista para receber as citações
    var citas []string

}

Agora, vamos abrir o arquivo txt:

package main

import (
    "fmt"
    "os"
    "bufio" 
)

func carregarCitations() ([]string, error) {

    // Abrir uma lista para receber as citações
    var citas []string

    // Abrir o arquivo txt com as citações
    arquivo, err := os.Open('quotes.txt')
    if err != nil {
        return nil, err // Retorna erro se falhar em abrir arquivo
    }
    defer arquivo.Close()   
}

Agora, nós vamos precisar criar um "scanner" para realizar a leitura do nosso arquivo de citações quotes.txt.

Ele também precisara ler cada linha do arquivo.

package main

import (
    "fmt"
    "os"
    "bufio" 
)

func carregarCitations() ([]string, error) {

    // Abrir uma lista para receber as citações
    var citas []string

    // Abrir o arquivo txt com as citações
    arquivo, err := os.Open('quotes.txt')
    if err != nil {
        return nil, err // Retorna erro se falhar em abrir arquivo
    }
    defer arquivo.Close()   

    // Criar scanner para leitura do arquivo txt
    scanner := bufio.NewScanner(arquivo)


    // Ler cada linha de cada arquivo
    for scanner.Scan() {
        linha := scanner.Text() // Obter o texto da linha
        citas = append(citas, linha) // Realiza a adição das linhas à lista/slice citas
    }
}

Agora, faremos a verificação do erro na leitura do arquivo txt de citações e o retorno da nossa lista com as citações que foram adicionadas à mesma.

package main

import (
    "fmt"
    "os"
    "bufio" 
)

func carregarCitations([]string, error) {

    // Abrir uma lista para receber as citações
    var citas []string

    // Abrir o arquivo txt com as citações
    arquivo, err := os.Open('quotes.txt')
    if err != nil {
        return nil, err // Retorna erro se falhar em abrir arquivo
    }
    defer arquivo.Close()   

    // Criar scanner para leitura do arquivo txt
    scanner := bufio.NewScanner(arquivo)

    // Ler cada linha de cada arquivo
    for scanner.Scan() {
        linha := scanner.Text() // Obter o texto da linha
        citas = append(citas, linha) // Realiza a adição das linhas à lista citas
    }

    // Verifica se houve erro na leitura do arq txt
    if err := scanner.Err(); err != nil {
        return nil, err
    }

    // Retornar nossa lista com citações
    return citas, nil // Retorna lista de citações
}

Agora precisamos criar a função main para retornar as citações e verificar se a função carregarCitations está correta:

func main() {
    citations, err := carregarCitations()
    if err != nil {
        fmt.Println("Erro ao carregar citações", err)
        return
    }

    for _, citation := range citations {
        fmt.Println(citation)
    }
}

O código deve estar assim:

package main

import (
    "fmt"
    "os"
    "bufio" 
)

func carregarCitations([]string, error) {

    // Abrir uma lista para receber as citações
    var citas []string

    // Abrir o arquivo txt com as citações
    arquivo, err := os.Open('quotes.txt')
    if err != nil {
        return nil, err // Retorna erro se falhar em abrir arquivo
    }
    defer arquivo.Close()   

    // Criar scanner para leitura do arquivo txt
    scanner := bufio.NewScanner(arquivo)

    // Ler cada linha de cada arquivo
    for scanner.Scan() {
        linha := scanner.Text() // Obter o texto da linha
        citas = append(citas, linha) // Realiza a adição das linhas à lista citas
    }

    // Verifica se houve erro na leitura do arq txt
    if err := scanner.Err(); err != nil {
        return nil, err
    }

    // Retornar nossa lista com citações
    return citas, nil // Retorna lista de citações
}

func main() {
    citations, err := carregarCitations()
    if err != nil {
        fmt.Println("Erro ao carregar citações", err)
        return
    }

    for _, citation := range citations {
        fmt.Println(citation)
    }
}

Agora vamos executar o código no terminal

go run main.go

Você deve visualizar todas as citações do seu arquivo quotes.txt em seu terminal.

Função `getRandomCitation`

Essa função usa a biblioteca math/rand para selecionar uma citação aleatória da lista.

Dentro dos parênteses da função (), você define os parâmetros que a função recebe como entrada. No exemplo:

citations []string significa que a função getRandomCitation espera um argumento chamado citations, que é um slice de strings (ou seja, uma lista de strings).

func getRandomCitation(citations []string

[]string é a sintaxe de Go para dizer "uma fatia de strings", ou seja, uma coleção ordenada de strings.

Quando você chama a função, você deve passar uma lista de citações (por exemplo, carregada do arquivo quotes.txt), e essa lista será usada dentro da função.

Após os parênteses de entrada, logo antes do corpo da função {}, você especifica o tipo de valor que a função vai retornar.

string logo após os parênteses significa que a função vai retornar uma string quando terminar de executar.

func getRandomCitation(citations []string) string {

Neste caso, a função vai retornar uma citação aleatória, que é uma única string.

Entretanto, precisamos gerar um valor aleatório, mas REALMENTE aleatório. Se utilizarmos somente rand.Seed(), a semente padrão será sempre a mesma. Por isso precisamos passar como parâmetros, outras duas funções:

time.Now(), que retorna o horário atual
UnixNano(), que converterá esse horário em um número inteiro, representando a quantidade de nanosegundos desde 1 de janeiro de 1970. A alta granularidade que é o pulo do gato XD

E depois precisamos que a função retorne um índice aleatório de citations de acordo com o tamanho da lista de citações (length)

import (
    "math/rand" // Não esqueça de incluir essa biblioteca
    "time"      // Não esqueça de incluir essa biblioteca
)

func getRandomCitation(citations []string) string {

    // Inicializa um número aleatório
    rand.Seed(time.Now().UnixNano())

    // Seleciona um índice aleatório de citations
    randomIndex := rand.Intn(len(citations))

    // Retorna uma citação aleatória
    return cictaions[randomIndex]

}

len(citations) retorna o número de citações no slice.
rand.Intn(n) gera um número aleatório entre 0 e n-1.
rand.Intn(len(citations)) seleciona um índice aleatório válido para acessar uma citação da lista.

E agora vamos alterar a função main, para imprimirmos a citação aleatória:

func main() {
    // Chama função para carregar as citações 
    citations, err := carregarCitations()
    if err != nil {
        fmt.Println("Erro ao carregar citações:", err)
        return
    }

    // Obtém uma citação aleatória de citations utilizando a função getRandomCitation
    randomCitation := getRandomCitation(citations)

    // Imprime a citação aleatória
    fmt.Println("Citação aleatória", randomCitation)

O nosso código deve estar assim:

package main

import (
    "bufio"
    "fmt"
    "os"
    "math/rand"
    "time"
)

// Função para carregar citações do arquivo quotes.txt
func carregarCitations() ([]string, error) {
    // Iniciar uma lista para receber todas as citações
    var citas []string

    // Abrir arquivo txt 
    arquivo, err := os.Open("quotes.txt")
    if err != nil {
        return nil, err // Retorna erro se falhar ao abrir o arquivo txt
    }
    defer arquivo.Close() // Garante o fechamento do arquivo ao final

    // Iniciar um scanner para leitura do arquivo
    scanner := bufio.NewScanner(arquivo)

    // Ler cada linha do arquivo txt
    for scanner.Scan() {
        linha := scanner.Text()
        citas = append(citas, linha)
    }

    // Verifica se houve algum erro durante a leitura do arquivo
    if err := scanner.Err(); err != nil {
        return nil, err
    }

    return citas, nil // Retorna lista de citações
}

func getRandomCitation(citations []string) string {
    // Inicializa o gerado de numero aleatório
    rand.Seed(time.Now().UnixNano())

    // Seleciona um índice aleatório
    randomIndex := rand.Intn(len(citations))

    // Retornar uma citação aleatório
    return citations[randomIndex]
}

func main() {
    // Chama a função para cerregar citações    
    citations, err := carregarCitations()
    if err != nil {
        fmt.Println("Erro ao carregar citações:", err)
        return
    }

    // Obtém uma citação aleatória de citations utilizando a função getRandomCitation
    randomCitation := getRandomCitation(citations)

    // Imprime a citação aleatória
    fmt.Println("Citação aleatória:", randomCitation)
}

Agora rode o main.go em seu terminal a fim de verificar se conseguimos uma citação aleatória:

go rum main.go

Função `imprimirGato`

Essa função exibe o desenho de um gato em ASCII e imprime a citação dentro de um balão de diálogo.

func imprimirGato(citacao string) {
    tamanhoBalao := len(citacao)
    linhaTopo := " " + strings.Repeat("-", tamanhoBalao+2)
    linhaCima := "/" + strings.Repeat(" ", tamanhoBalao+2) + "\\"
    linhaCitacao := fmt.Sprintf("| %s |", citacao)
    linhaBaixo := "\\" + strings.Repeat(" ", tamanhoBalao+2) + "/"
    linhaBase := " " + strings.Repeat("-", tamanhoBalao+2)

    // Imprime o balão de diálogo
    fmt.Println(linhaTopo)
    fmt.Println(linhaCima)
    fmt.Println(linhaCitacao)
    fmt.Println(linhaBaixo)
    fmt.Println(linhaBase)

    // Imprime o desenho do gato em ASCII com barras escapadas corretamente
    fmt.Println(`        \   
             \  
               ,_     _
               |\\_,-~/
               / _  _ |    ,--.
              (  @  @ )   / ,-'
               \  _T_/-._( (
               /         \. \
              |         _  \ |
               \ \ ,  /      |
                || |-_\__   /
               ((_/` + "`(____,-'`)")
}

Função `main`

Na função main(), o programa carrega as citações, seleciona uma aleatória e imprime o gato com a citação em um balão.

func main() {
    // Carregar as citações do arquivo
    citations, err := carregarCitations()
    if err != nil {
        fmt.Println("Erro ao carregar citações:", err)
        return
    }

    // Obter uma citação aleatória
    randomCitation := getRandomCitation(citations)

    // Imprimir o balão com o gato e a citação aleatória
    imprimirGato(randomCitation)
}

Nosso código final deve estar assim:

package main

import (
    "bufio"
    "fmt"
    "math/rand"
    "os"
    "strings"
    "time"
)

// Função para carregar citações do arquivo quotes.txt
func carregarCitations() ([]string, error) {
    var citas []string

    arquivo, err := os.Open("quotes.txt")
    if err != nil {
        return nil, err
    }
    defer arquivo.Close()

    scanner := bufio.NewScanner(arquivo)
    for scanner.Scan() {
        linha := scanner.Text()
        citas = append(citas, linha)
    }

    if err := scanner.Err(); err != nil {
        return nil, err
    }

    return citas, nil
}

func getRandomCitation(citations []string) string {
    rand.Seed(time.Now().UnixNano())
    randomIndex := rand.Intn(len(citations))
    return citations[randomIndex]
}

func imprimirGato(citacao string) {
    tamanhoBalao := len(citacao)
    linhaTopo := " " + strings.Repeat("-", tamanhoBalao+2)
    linhaCima := "/" + strings.Repeat(" ", tamanhoBalao+2) + "\\"
    linhaCitacao := fmt.Sprintf("| %s |", citacao)
    linhaBaixo := "\\" + strings.Repeat(" ", tamanhoBalao+2) + "/"
    linhaBase := " " + strings.Repeat("-", tamanhoBalao+2)

    // Imprime o balão de diálogo
    fmt.Println(linhaTopo)
    fmt.Println(linhaCima)
    fmt.Println(linhaCitacao)
    fmt.Println(linhaBaixo)
    fmt.Println(linhaBase)

    // Imprime o desenho do gato em ASCII com barras escapadas corretamente
    fmt.Println(`        \   
             \  
               ,_     _
               |\\_,-~/
               / _  _ |    ,--.
              (  @  @ )   / ,-'
               \  _T_/-._( (
               /         \. \
              |         _  \ |
               \ \ ,  /      |
                || |-_\__   /
               ((_/` + "`(____,-'`)")
}

func main() {
    citations, err := carregarCitations()
    if err != nil {
        fmt.Println("Erro ao carregar citações:", err)
        return
    }

    randomCitation := getRandomCitation(citations)
    imprimirGato(randomCitation)
}

Finalizando

Agora nos resta compilar nosso programa e executar.

Compile seu arquivo main.go como fcat:

go build -o fcat main.go

E por fim, execute:

./fcat

O resultado foi esse:

 ------------------------------------------------------
/                                                      \
| He who has a why to live for can bear almost any how |
\                                                      /
 ------------------------------------------------------
        \
             \
               ,_     _
               |\\_,-~/
               / _  _ |    ,--.
              (  @  @ )   / ,-'
               \  _T_/-._( (
               /         \. \
              |         _  \ |
               \ \ ,  /      |
                || |-_\__   /
               ((_/`(____,-'`)

Achei interessante como algo tão simples pode se tornar tão complicado de executar.

Mas o que me impressionou foi a frase de saída do programa: "He who has a why to live for can bear almost any how"

Que a frase acima lhe inspire a continuar aprendendo.

REPO: https://github.com/ionnss/fcat

ions,

Mais um dia na terra

Forem: ionnss

Scrapper Concorrente

Objetivo do programa

Explicação do Código

Pacotes utilizados

Função fetchTitle

Requisição HTTP

Verificação de Status

Carregamento e Busca do Título

Função main

Configuração do WaitGroup e do Canal

Início das Goroutines

Espera e Exibição dos Resultados

Organizador de arquivos em GO

Estrutura do projeto

Iniciando o projeto

Parte 1: Verificando se um diretório existe

Parte 2: Conceito de função de "callback" é uma doidera, bixo!

Exemplo em Ação

Função de Callback

PARTE 3: ORGANIZAR != ORGANIZADO

Estrutura da função organizarArquivos

Filtrando arquivos e ignorando diretórios ocultos

Identificando a extensão do arquivo e criando o nome da subpasta

Criando a subpasta, caso ainda não exista

Definindo o caminho de destino do arquivo

Verificando se o arquivo já está na pasta de destino

Resumo Final

Nietzsche reencarnado num gato, uma "ferramente" CLI feita com GO

FCAT?

Qual é o problema?

Letes go, bebê

Explicação do código:

Função carregarCitations

Função getRandomCitation

Função imprimirGato

Função main

Finalizando

Função `fetchTitle`

Função `main`

Função `carregarCitations`

Função `getRandomCitation`

Função `imprimirGato`

Função `main`