Módulo Table

O módulo table estende as funcionalidades padrão de manipulação de tabelas do Lua, fornecendo funções adicionais úteis para processamento de dados. Este módulo complementa as funções nativas da tabela table do Lua, adicionando operações comuns que não estão disponíveis na biblioteca padrão.
Características principais:
Extensão da tabela table nativa do Lua
Funções otimizadas para performance
Funções Disponíveis
1. table.contains(tabela, valor)
Verifica se um valor específico está presente em uma tabela Lua.
Parâmetros:

tabela (tabela): A tabela a ser verificada (pode ser array ou tabela associativa)

valor (qualquer tipo Lua): O valor a ser procurado na tabela
Retorno:

boolean: true se o valor for encontrado na tabela, false caso contrário
Comportamento:
Percorre todos os pares chave-valor da tabela usando pairs()

Compara cada valor com o valor procurado usando igualdade estrita (==)
Retorna true na primeira ocorrência encontrada
Retorna false se percorrer toda a tabela sem encontrar o valor
Funciona com tabelas indexadas numericamente (arrays) e tabelas associativas
Exemplo de Uso:
-- Verificar se um valor existe em um array
local frutas = {"maçã", "banana", "laranja", "uva"}
local tem_banana = table.contains(frutas, "banana")
print("Tem banana?", tem_banana) -- true

local tem_morango = table.contains(frutas, "morango")
print("Tem morango?", tem_morango) -- false

-- Verificar em tabela associativa
local configuracoes = {
 timeout = 30,
 retries = 3,
 debug = false,
 hostname = "servidor.local"
}

local tem_timeout = table.contains(configuracoes, 30)
print("Tem valor 30?", tem_timeout) -- true

local tem_true = table.contains(configuracoes, true)
print("Tem valor true?", tem_true) -- false

-- Verificar tipos complexos
local usuarios = {
 {id = 1, nome = "Alice", ativo = true},
 {id = 2, nome = "Bob", ativo = false},
 {id = 3, nome = "Carol", ativo = true}
}

-- Para tipos complexos, precisa ser a mesma referência
local usuario_bob = usuarios[2]
local encontrou_bob = table.contains(usuarios, usuario_bob)
print("Encontrou Bob?", encontrou_bob) -- true

-- Esta busca retornará false porque é um novo objeto
local encontrou_novo_bob = table.contains(usuarios, {id = 2, nome = "Bob", ativo = false})
print("Encontrou novo Bob?", encontrou_novo_bob) -- false

2. table.slice(tabela, primeiro, último)
Extrai uma fatia (subarray) de uma tabela indexada numericamente (array).
Parâmetros:

tabela (tabela): O array Lua do qual extrair a fatia

primeiro (número, opcional): Índice inicial da fatia (padrão: 1)

último (número, opcional): Índice final da fatia (padrão: comprimento da tabela)
Retorno:

tabela: Novo array contendo os elementos da fatia especificada
Comportamento:
Cria uma nova tabela contendo os elementos do índice primeiro até último (inclusive)
Se primeiro for omitido ou nil, começa do primeiro elemento (índice 1)
Se último for omitido ou nil, vai até o último elemento da tabela
Se primeiro for maior que último, a função ainda itera mas os valores serão nil para índices inexistentes
Não realiza verificação de limites - índices fora do intervalo da tabela resultarão em valores nil

Preserva a ordem original dos elementos
Exemplo de Uso:
-- Extrair parte de um array
local numeros = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100}

-- Fatia do índice 3 ao 7
local fatia1 = table.slice(numeros, 3, 7)
-- fatia1 = {30, 40, 50, 60, 70}

-- Fatia do início até o índice 5
local fatia2 = table.slice(numeros, nil, 5)
-- fatia2 = {10, 20, 30, 40, 50}

-- Fatia do índice 8 até o final
local fatia3 = table.slice(numeros, 8)
-- fatia3 = {80, 90, 100}

-- Fatia com índices fora dos limites
local fatia4 = table.slice(numeros, -2, 15)
-- fatia4 = {nil, nil, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, nil, nil, nil, nil, nil} (não trata limites)

-- Fatia com primeiro > último
local fatia5 = table.slice(numeros, 5, 3)
-- fatia5 = {50, 40, 30} (itera em ordem decrescente)

-- Processamento de dados em lotes
local function processar_em_lotes(dados, tamanho_lote)
 local lotes = {}
 local total = #dados

 for i = 1, total, tamanho_lote do
 local fim = math.min(i + tamanho_lote - 1, total)
 local lote = table.slice(dados, i, fim)
 table.insert(lotes, lote)
 end

 return lotes
end

local dados_grandes = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
local lotes = processar_em_lotes(dados_grandes, 5)
-- lotes = {{1,2,3,4,5}, {6,7,8,9,10}, {11,12,13,14,15}}