// ============================================
// GO AVANÇADO: PROCESSAMENTO DE DADOS
// ============================================
// Guia completo sobre processamento eficiente de dados,
// desde parsing até transformação, agregação e análise
// ============================================
// SUMÁRIO COMPLETO
// ============================================
// PARSING E CONVERSÃO
// 1. Parsing de strings
// 2. Regular expressions
// 3. CSV parsing
// 4. JSON processing
// 5. XML parsing
//
// TRANSFORMAÇÃO
// 6. Map/Filter/Reduce
// 7. Transformação de tipos
// 8. Normalização de dados
// 9. Deduplicação
// 10. Merge de datasets
//
// AGREGAÇÃO
// 11. Grouping
// 12. Sorting avançado
// 13. Estatísticas
// 14. Window functions
// 15. Time-series aggregation
//
// STREAMING
// 16. Lazy evaluation
// 17. Generators
// 18. Pipelines de dados
// 19. Backpressure handling
// 20. Chunking e batching
//
// PERFORMANCE
// 21. Memory pooling
// 22. Parallelização
// 23. Caching
// 24. Lazy loading
// 25. Index structures
package main
import (
"fmt"
"regexp"
"sort"
"strconv"
"strings"
)
// ============================================
// 1. PARSING DE STRINGS
// ============================================
func exemplo_parsing_strings() {
// Conversão básica
numero := "42"
n, err := [Link](numero)
if err == nil {
[Link]("String '%s' convertida: %d\n", numero, n)
}
// Parsing de float
f, _ := [Link]("3.14159", 64)
[Link]("Float: %f\n", f)
// Parsing de bool
b, _ := [Link]("true")
[Link]("Bool: %v\n", b)
// Split e parsing
dados := "10,20,30,40"
parts := [Link](dados, ",")
var numeros []int
for _, p := range parts {
n, _ := [Link](p)
numeros = append(numeros, n)
}
[Link]("Números: %v\n", numeros)
}
// ============================================
// 2. REGULAR EXPRESSIONS
// ============================================
func exemplo_regex() {
texto := "Email: joao@[Link], telefone: 123-456-7890"
// Compilar regex
emailRegex := [Link](`\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-
z]{2,}\b`)
emails := [Link](texto, -1)
[Link]("Emails encontrados: %v\n", emails)
// Encontrar posição
phoneRegex := [Link](`\d{3}-\d{3}-\d{4}`)
posicao := [Link](texto)
if posicao != nil {
[Link]("Telefone em posição: %d-%d\n", posicao[0], posicao[1])
}
// Replace com regex
resultado := [Link](texto, "XXX-XXX-XXXX")
[Link]("Texto mascarado: %s\n", resultado)
// Split com regex
dados := "maçã,banana;laranja:uva"
frutas := [Link](`[,;:]`).Split(dados, -1)
[Link]("Frutas: %v\n", frutas)
}
// ============================================
// 3. CSV PARSING
// ============================================
import "encoding/csv"
import "bytes"
func exemplo_csv_parsing() {
csvData := `Nome,Idade,Cidade
João,30,São Paulo
Maria,25,Rio de Janeiro
Pedro,35,Belo Horizonte`
reader := [Link]([Link](csvData))
records, _ := [Link]()
[Link]("CSV Parsing:")
for i, record := range records {
if i == 0 {
continue // pular header
}
[Link]("- %s, %s anos, %s\n", record[0], record[1], record[2])
}
// Escrever CSV
var buf [Link]
writer := [Link](&buf)
[Link]([]string{"Produto", "Preço", "Estoque"})
[Link]([]string{"Notebook", "3000", "5"})
[Link]([]string{"Mouse", "50", "20"})
[Link]()
[Link]("\nCSV gerado:")
[Link]([Link]())
}
// ============================================
// 4. JSON PROCESSING
// ============================================
import "encoding/json"
type Pessoa struct {
Nome string `json:"nome"`
Idade int `json:"idade"`
Email string `json:"email"`
}
func exemplo_json_processing() {
// Parse JSON
jsonStr := `[
{"nome":"Alice","idade":30,"email":"alice@[Link]"},
{"nome":"Bob","idade":25,"email":"bob@[Link]"}
]`
var pessoas []Pessoa
[Link]([]byte(jsonStr), &pessoas)
[Link]("Pessoas parseadas: %d\n", len(pessoas))
// Converter para JSON
novasPessoas := []Pessoa{
{Nome: "Carol", Idade: 28, Email: "carol@[Link]"},
}
jsonOutput, _ := [Link](novasPessoas, "", " ")
[Link]("JSON output:")
[Link](string(jsonOutput))
// JSON customizado com map
var dados map[string]interface{}
[Link]([]byte(`{"chave":"valor","numero":42}`), &dados)
[Link]("Dados: %v\n", dados)
}
// ============================================
// 6. MAP/FILTER/REDUCE
// ============================================
// Map: transformar cada elemento
func Map_Int(slice []int, fn func(int) int) []int {
resultado := make([]int, len(slice))
for i, v := range slice {
resultado[i] = fn(v)
}
return resultado
}
// Filter: manter apenas elementos que passam no teste
func Filter_Int(slice []int, fn func(int) bool) []int {
var resultado []int
for _, v := range slice {
if fn(v) {
resultado = append(resultado, v)
}
}
return resultado
}
// Reduce: agregar valores em um resultado único
func Reduce_Int(slice []int, inicial int, fn func(int, int) int) int {
resultado := inicial
for _, v := range slice {
resultado = fn(resultado, v)
}
return resultado
}
func exemplo_map_filter_reduce() {
numeros := []int{1, 2, 3, 4, 5, 6}
// Map: dobrar cada número
dobrados := Map_Int(numeros, func(n int) int {
return n * 2
})
[Link]("Dobrados: %v\n", dobrados)
// Filter: manter apenas pares
pares := Filter_Int(numeros, func(n int) bool {
return n%2 == 0
})
[Link]("Pares: %v\n", pares)
// Reduce: somar todos
soma := Reduce_Int(numeros, 0, func(acc, n int) int {
return acc + n
})
[Link]("Soma: %d\n", soma)
// Composição: dobrar apenas pares e somar
pares_dobrados := Map_Int(Filter_Int(numeros, func(n int) bool {
return n%2 == 0
}), func(n int) int {
return n * 2
})
soma_pares := Reduce_Int(pares_dobrados, 0, func(acc, n int) int {
return acc + n
})
[Link]("Soma de pares dobrados: %d\n", soma_pares)
}
// ============================================
// 11. GROUPING
// ============================================
type Venda struct {
Vendedor string
Valor float64
Data string
}
func exemplo_grouping() {
vendas := []Venda{
{"Alice", 1000, "2024-01-01"},
{"Bob", 500, "2024-01-01"},
{"Alice", 1500, "2024-01-02"},
{"Bob", 800, "2024-01-02"},
}
// Agrupar por vendedor
grupos := make(map[string]float64)
for _, v := range vendas {
grupos[[Link]] += [Link]
}
[Link]("Vendas por vendedor:")
for vendedor, total := range grupos {
[Link]("%s: R$ %.2f\n", vendedor, total)
}
// Agrupar com slice de valores
grupos_detalhe := make(map[string][]Venda)
for _, v := range vendas {
grupos_detalhe[[Link]] = append(grupos_detalhe[[Link]], v)
}
[Link]("\nDetalhes por vendedor:")
for vendedor, vendas_vendedor := range grupos_detalhe {
[Link]("%s: %d vendas\n", vendedor, len(vendas_vendedor))
}
}
// ============================================
// 12. SORTING AVANÇADO
// ============================================
func exemplo_sorting_avancado() {
pessoas := []Pessoa{
{Nome: "Alice", Idade: 30, Email: "alice@[Link]"},
{Nome: "Bob", Idade: 25, Email: "bob@[Link]"},
{Nome: "Carol", Idade: 28, Email: "carol@[Link]"},
}
// Sort por idade
[Link](pessoas, func(i, j int) bool {
return pessoas[i].Idade < pessoas[j].Idade
})
[Link]("Ordenado por idade:")
for _, p := range pessoas {
[Link]("%s: %d\n", [Link], [Link])
}
// Sort por nome (reverse)
[Link](pessoas, func(i, j int) bool {
return pessoas[i].Nome > pessoas[j].Nome
})
[Link]("\nOrdenado por nome (Z-A):")
for _, p := range pessoas {
[Link]("%s\n", [Link])
}
// Multi-chave sort
vendas := []Venda{
{"Alice", 1000, "2024-01-02"},
{"Bob", 500, "2024-01-01"},
{"Alice", 1500, "2024-01-01"},
}
[Link](vendas, func(i, j int) bool {
if vendas[i].Data != vendas[j].Data {
return vendas[i].Data < vendas[j].Data
}
return vendas[i].Valor > vendas[j].Valor
})
[Link]("\nVendas ordenadas (data, depois valor desc):")
for _, v := range vendas {
[Link]("%s - %s: R$ %.2f\n", [Link], [Link], [Link])
}
}
// ============================================
// 13. ESTATÍSTICAS
// ============================================
func exemplo_estatisticas() {
dados := []float64{10, 20, 30, 40, 50, 60}
// Média
soma := 0.0
for _, v := range dados {
soma += v
}
media := soma / float64(len(dados))
[Link]("Média: %.2f\n", media)
// Mediana
sort.Float64s(dados)
var mediana float64
n := len(dados)
if n%2 == 0 {
mediana = (dados[n/2-1] + dados[n/2]) / 2
} else {
mediana = dados[n/2]
}
[Link]("Mediana: %.2f\n", mediana)
// Desvio padrão
variancia := 0.0
for _, v := range dados {
diff := v - media
variancia += diff * diff
}
variancia /= float64(len(dados))
desvio := variancia * variancia
for i := 0; i < 50; i++ {
desvio = (desvio + variancia/desvio) / 2
}
[Link]("Desvio padrão: %.2f\n", desvio)
// Min/Max
min, max := dados[0], dados[0]
for _, v := range dados {
if v < min {
min = v
}
if v > max {
max = v
}
}
[Link]("Min: %.0f, Max: %.0f\n", min, max)
}
// ============================================
// 16. LAZY EVALUATION (COM CHANNELS)
// ============================================
// Generator produz valores sob demanda
func Gerar_Numeros(max int) <-chan int {
ch := make(chan int)
go func() {
for i := 1; i <= max; i++ {
ch <- i
}
close(ch)
}()
return ch
}
// Lazy filter
func Filtrar_Lazy(in <-chan int, fn func(int) bool) <-chan int {
ch := make(chan int)
go func() {
for v := range in {
if fn(v) {
ch <- v
}
}
close(ch)
}()
return ch
}
// Lazy map
func Mapear_Lazy(in <-chan int, fn func(int) int) <-chan int {
ch := make(chan int)
go func() {
for v := range in {
ch <- fn(v)
}
close(ch)
}()
return ch
}
func exemplo_lazy_evaluation() {
// Pipeline: gerar -> filtrar pares -> dobrar
numeros := Gerar_Numeros(10)
pares := Filtrar_Lazy(numeros, func(n int) bool {
return n%2 == 0
})
dobrados := Mapear_Lazy(pares, func(n int) int {
return n * 2
})
[Link]("Lazy pipeline (pares dobrados):")
for v := range dobrados {
[Link]("%d ", v)
}
[Link]()
}
// ============================================
// 20. CHUNKING E BATCHING
// ============================================
func Chunking(slice []int, tamanho int) [][]int {
var chunks [][]int
for i := 0; i < len(slice); i += tamanho {
fim := i + tamanho
if fim > len(slice) {
fim = len(slice)
}
chunks = append(chunks, slice[i:fim])
}
return chunks
}
func exemplo_chunking() {
dados := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
chunks := Chunking(dados, 3)
[Link]("Dados em chunks de 3:")
for i, chunk := range chunks {
[Link]("Chunk %d: %v\n", i+1, chunk)
}
// Processar em batch
[Link]("\nProcessando em batch:")
for _, batch := range Chunking(dados, 4) {
soma := 0
for _, v := range batch {
soma += v
}
[Link]("Batch: %v, soma: %d\n", batch, soma)
}
}
// ============================================
// 21. DEDUPLICAÇÃO
// ============================================
func Deduplicate_Int(slice []int) []int {
seen := make(map[int]bool)
var resultado []int
for _, v := range slice {
if !seen[v] {
seen[v] = true
resultado = append(resultado, v)
}
}
return resultado
}
func exemplo_deduplicacao() {
dados := []int{1, 2, 2, 3, 4, 4, 4, 5}
unico := Deduplicate_Int(dados)
[Link]("Original: %v\n", dados)
[Link]("Deduplicated: %v\n", unico)
}
// ============================================
// 23. CACHING
// ============================================
type Cache_LRU struct {
dados map[string]interface{}
ordem []string
tamanho int
}
func Novo_Cache_LRU(tamanho int) *Cache_LRU {
return &Cache_LRU{
dados: make(map[string]interface{}),
ordem: make([]string, 0),
tamanho: tamanho,
}
}
func (c *Cache_LRU) Set(chave string, valor interface{}) {
if _, existe := [Link][chave]; !existe && len([Link]) >= [Link] {
// Remover mais antigo (LRU)
antiga := [Link][0]
delete([Link], antiga)
[Link] = [Link][1:]
}
[Link][chave] = valor
[Link] = append([Link], chave)
}
func (c *Cache_LRU) Get(chave string) (interface{}, bool) {
val, existe := [Link][chave]
return val, existe
}
func exemplo_caching() {
cache := Novo_Cache_LRU(3)
[Link]("a", 1)
[Link]("b", 2)
[Link]("c", 3)
val, _ := [Link]("a")
[Link]("Cache 'a': %v\n", val)
// Adicionar novo deve remover LRU
[Link]("d", 4)
_, existe := [Link]("b")
[Link]("'b' ainda em cache: %v\n", existe)
}
// ============================================
// MAIN FUNCTION
// ============================================
func main() {
[Link]("=== Processamento de Dados em Go ===\n")
[Link]("--- Parsing Strings ---")
exemplo_parsing_strings()
[Link]("\n--- Regex ---")
exemplo_regex()
[Link]("\n--- CSV Parsing ---")
exemplo_csv_parsing()
[Link]("\n--- JSON Processing ---")
exemplo_json_processing()
[Link]("\n--- Map/Filter/Reduce ---")
exemplo_map_filter_reduce()
[Link]("\n--- Grouping ---")
exemplo_grouping()
[Link]("\n--- Sorting Avançado ---")
exemplo_sorting_avancado()
[Link]("\n--- Estatísticas ---")
exemplo_estatisticas()
[Link]("\n--- Lazy Evaluation ---")
exemplo_lazy_evaluation()
[Link]("\n--- Chunking ---")
exemplo_chunking()
[Link]("\n--- Deduplicação ---")
exemplo_deduplicacao()
[Link]("\n--- Caching ---")
exemplo_caching()
}