Lua Iteradores: guia completo
Os iteradores Lua permitem iterar sobre estruturas de dados complexas, como tabelas , arrays e até mesmo tipos de dados definidos pelo usuário de maneira limpa, concisa e eficiente.
Os iteradores podem ser usados para simplificar o código, reduzir erros e tornar o código mais legível e fácil de manter.
Os iteradores Lua podem ser classificados como sem estado ou com estado com base em manter ou não qualquer estado interno.
O foco deste artigo serão os iteradores em Lua.
Iteradores de Lua sem Estado
Um iterador sem estado é aquele que não mantém nenhum estado interno e simplesmente retorna o próximo valor na sequência.
Cada chamada para a função iteradora é independente de qualquer chamada anterior.
Aqui está um exemplo de um iterador sem estado:
Example:
Alguns iteradores sem estado integrados são:
ipairs()
Esta função itera sobre arrays com chaves inteiras em ordem numérica.
Uma matriz é passada para a função como um argumento e ela retorna uma função iteradora que pode ser usada para percorrer os elementos da matriz.
O exemplo abaixo é usado para demonstrar a função ipairs onde a tabela é passada como argumento:
Example:
pares()
Esta função é usada para iterar sobre tabelas.
Ele retorna uma função iteradora que itera sobre os pares chave-valor em uma tabela.
O exemplo a seguir trata da função pairs em Lua que recebe a tabela como argumento:
Example:
próximo()
Ele permite iterar sobre uma tabela.
Ele recebe dois argumentos: uma tabela e uma chave, e retorna o próximo par chave-valor na tabela seguinte à chave fornecida.
Se a chave fornecida for nula, next() retorna o primeiro par chave-valor da tabela.
Vamos explorar esta função usando como exemplo:
Example:
string.gmatch()
A função string.gmatch() em Lua recebe uma string e um padrão como entrada e retorna uma função iteradora que pode ser usada para iterar todas as correspondências do padrão na string especificada.
A função do iterador gera cada correspondência em tempo real, com base na string de entrada e no padrão fornecido a ela.
O exemplo a seguir ilustra a função string.gmatch em Lua:
Example:
Iteradores Lua Stateful
O iterador com estado Lua é aquele que mantém algum estado interno entre as chamadas para a função do iterador.
O estado pode ser usado para rastrear onde o iterador está na sequência ou para executar alguma outra função.
Vamos dar uma olhada em um exemplo de iterador com estado:
Example:
Alguns iteradores com estado integrados são:
coroutine.wrap()
Ele cria uma função iteradora que pode ser retomada com a função coroutine.resume().
Nenhum argumento é necessário para a função do iterador e vários valores são retornados pela co-rotina.
Assim que a função co-rotina retornar, a função iteradora também retornará, indicando que a iteração foi concluída.
Os exemplos a seguir mostram a implementação da função coroutine.wrap() :
Example:
io.lines()
Esta função retorna um iterador para iterar nas linhas de um arquivo.
Ele usa um nome de arquivo ou um identificador de arquivo aberto como argumento e retorna um iterador que pode ser usado para percorrer as linhas do arquivo.
O trecho de código a seguir retrata a função io.lines() em Lua:
local file = io.open("my_file.txt", "r")
for line in io.lines(file) do
print(line)
end
io.close(file)
No exemplo acima, abrimos um arquivo local chamado my_file.txt para leitura e usamos a função io.lines() para percorrer as linhas do arquivo.
Cada linha é retornada como uma string e impressa no console .
Por fim, fechamos o identificador de arquivo usando a função io.close() .
Para manter-se atualizado com todos os avanços mais recentes em Lua, assine nosso boletim informativo abaixo.
