# Panic, Defer e Recover

Estava buscando temas e coisas ainda não abordadas. E vi que ainda não falei especificamente sobre Panic, Defer e Recover. Hoje vamos falar mais osbre o Defer.

# Defer

O defer é muito simples, ele agenda um execução para logo antes do return da atual função. Veja esse exemplo:

func deferExemplo() {
    fmt.Println("Início")
    defer fmt.Println("Fim")
    fmt.Println("Meio")
}

A saída será:

# Criando um linter básico com golang - Buscando ifs dentro de ifs

Pensei em criar um função que analisa o código em busca de ifs aninhados. Vamos usar a mesma base do projeto e só adicionar mais duas funções no arquivo de regras.

Vamos fazer o mesmo esquema com o ast.Inspect e avaliar node por node. Aqui vou fazer um switch no statement, para no caso de adicionar mais algumas verificações, mas poderia ser um if para validar se o statement é um if.

# Criando um linter básico com golang

Um linter é uma ferramenta que analisa o código e encontra problemas de estilo, inconsistências, possíveis erros, … Ele funciona como um corretor gramatical e de estilo para o código, sem realmente executá-lo, faz isso através de uma análise estática. No Python temos o ruff, Pylint, Flake8, no javascript temos o eslint e no golang temo o golangci-lint. E de forma bem resumida eles funcionam da seguinte forma: o linter “lê” o código, gera uma árvore AST (árvore de sintaxe abstrata) e o linter lê essa árvore aplicando regras. No golang temos Oo pacote go/ast permite ler, analisar e manipular o código-fonte Go como uma árvore de sintaxe abstrata. Vamos criar o victorlinter todas as funções devem começar com o nome victor.

# Manipulação de caminhos com path/filepath

O pacote path/filepath serve para manipular caminhos de arquivos de forma segura e multiplataforma.O pacote path trata caminhos com separadores do estilo Unix (/), independentemente do sistema operacional. É ideal para caminhos de URLs ou caminhos internos de sistemas de arquivos virtuais. Já o path/filepath trata caminhos do sistema de arquivos local, respeitando as convenções do sistema operacional (como \ no Windows e / no Linux).

# Ordenação com o pacote sort

Podemos implementar uma ordenação na “unha” ou usar o pacote sort que já traz implementações extremamente otimizadas de algoritmos eficientes e tudo isso com suporte a vários tipos de dados. Vamos ver hoje como fazer ordenações no Go.

Primeiro temos que importar o pacote, lembrando que ele é um pacote padrão do Golang:

import "sort"

De forma geral, existe uma método para cada tipo, então para ordenar um slice de inteiros usamos sort.Ints, floats sort.Float64s

# Precisão quase infinita com math/big

Vamos fazer um programa para calcular o fatorial de 1000.

package main

import "fmt"

func main() {
	var total uint64 = 1
	for i := 1; i < 1000; i++ {
		total = total * uint64(i)
	}
	fmt.Println(total)
}

Qual vai ser o resultado da operação?

➜  go run main.go
0

Zero! Isso mesmo! O que ocorre aqui é um problema de overflow, o valor de total excede o valor máximo que um uint64 pode armazenar (2**64 −1) e ocorre um estouro de memória. Em Go (e na maioria das linguagens de programação para tipos inteiros sem sinal), quando um overflow ocorre, o número “dá a volta” (wrap around). Ele começa a contar a partir de 0 novamente.

# Webscrapping com Colly

Colly é uma biblioteca de scraping para usar em golang. Com ela, conseguimos navegar por páginas HTML, capturar informações específicas, preencher formulários e até mesmo simular interações de usuário. Vamos fazer um script para pegar todos os dados do blog. Vamos iniciar um projeto e instalar a lib

go get -u github.com/gocolly/colly/v2

A arquitetura do colly é toda baseada em callbacks. Veja a documentação do Colly para saber mais. Sempre temos que inicial um collector c := colly.NewCollector() o Collector gerencia a comunicação de rede e é responsável pela execução dos callbacks associados enquanto o scraping está em execução.

# Jogo usando bubbletea e lipgloss - Parte 2

Ontem criamos a base do jogo e estruturamos o projeto, hoje faremos a lógica usando o bubbletea e o lipgloss.

Vamos começar criando as estilizações dos textos. A documentação do lipgloss é muito legal e tem vários exemplos de como usar a biblioteca.

var (
	estiloJogador    = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("2"))
	estiloComputador = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("1"))
	estiloVencedor   = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("10"))
	estiloPlacar     = lipgloss.NewStyle().Foreground(lipgloss.Color("11"))
)

E depois passmos para a estrutura do bubbletea, seguindo o padrão Model, View e Update.

# Jogo usando bubbletea e lipgloss

No post de hoje vamos fazer um jogo usando o bubbletea e o lipgloss. A ideia é só fazer um “baralho” e o jogador tira uma carta e o computador tira outra, quem tiver a carta mais alta vence. Em caso de empate no valor, o critério de desempate é a sequência de naipes.

Iniciamos o projeto:

go mod init jogo-cartas-tui

Instalação das libs:

# Iniciando uma TUI - Terminal User Interface

Vamos verificar um lib muito legal do ecosistema, para a criação de Interfaces de usuário no terminal (TUIs), a Bubble Tea e aproveitar para ver a lib lipgloss. Vamos iniciar nosso projeto e instalar essas duas libs:

go get github.com/charmbracelet/bubbletea
go get github.com/charmbracelet/lipgloss

O Bubble Tea segue uma arquitetura bem definida:

1. Model: Representa o estado da aplicação.
2. Update: Lida com as atualizações de estado.
3. View: Define como a interface é renderizada.

Esse código gera uma TUI, quando apertamos “i” um contador é incrementado, “d” decrementado e “q” a aplicação encerra.