O que são table e metatable em Lua?

Hoje vamos aprender sobre a única estrutura de dados no LuaJIT: a table.

Ao contrário de outras linguagens de script com estruturas de dados ricas, o LuaJIT possui apenas uma estrutura de dados, a table, que não é distinguida entre arrays, hashes, coleções, etc., mas é uma mistura de tudo. Vamos revisar um dos exemplos mencionados anteriormente.

local color = {first = "red", "blue", third = "green", "yellow"}
print(color["first"])                 --> output: red
print(color[1])                         --> output: blue
print(color["third"])                --> output: green
print(color[2])                         --> output: yellow
print(color[3])                         --> output: nil

Neste exemplo, a tabela color contém um array e um hash e pode ser acessada sem interferência mútua. Por exemplo, você pode usar a função ipairs para iterar apenas pela parte do array da tabela.

$ resty -e 'local color = {first = "red", "blue", third = "green", "yellow"}
for k, v in ipairs(color) do
      print(k)
end
'

As operações com table são tão cruciais que o LuaJIT estende a biblioteca padrão de tabelas do Lua 5.1, e o OpenResty estende ainda mais a biblioteca de tabelas do LuaJIT. Vamos dar uma olhada em cada uma dessas funções da biblioteca.

As funções da biblioteca table

Vamos começar com as funções padrão da biblioteca table. O Lua 5.1 não tem muitas funções na biblioteca table, então podemos passar rapidamente por elas.

`table.getn` Obter o número de elementos

Como mencionamos no capítulo Lua Padrão e LuaJIT, obter o número correto de todos os elementos da tabela é um grande problema no LuaJIT.

Para sequências, você pode usar table.getn ou o operador unário # para retornar o número correto de elementos. O exemplo a seguir retorna o número 3, como esperado.

$ resty -e 'local t = { 1, 2, 3 }
  print(table.getn(t))

O valor correto não pode ser retornado para tabelas que não são sequenciais. No segundo exemplo, o valor retornado é 1.

$ resty -e 'local t = { 1, a = 2 }
  print(#t) '

Felizmente, tais funções difíceis de entender foram substituídas por extensões do LuaJIT, que mencionaremos mais tarde. Portanto, no contexto do OpenResty, não use a função table.getn e o operador unário #, a menos que você saiba explicitamente que está obtendo o comprimento de uma sequência.

Além disso, table.getn e o operador unário # não têm complexidade de tempo O(1), mas O(n), o que é outro motivo para evitá-los, se possível.

`table.remove` Remove o elemento especificado

A segunda é a função table.remove, que remove elementos na tabela com base em subscritos, ou seja, apenas os elementos na parte do array da tabela podem ser removidos. Vamos olhar novamente o exemplo color.

$ resty -e 'local color = {first = "red", "blue", third = "green", "yellow"}
  table.remove(color, 1)
  for k, v in pairs(color) do
      print(v)
  end'

Este código removerá o blue com subscrito 1. Você pode perguntar: como eu removo a parte do hash da tabela? É tão simples quanto definir o valor correspondente à chave como nil. Assim, no exemplo color, o green correspondente a third é removido.

$ resty -e 'local color = {first = "red", "blue", third = "green", "yellow"}
  color.third = nil
  for k, v in pairs(color) do
      print(v)
  end'

`table.concat` Função de concatenação de elementos

A terceira é a função de concatenação de elementos table.concat. Ela concatena os elementos da tabela de acordo com os subscritos. Como isso é novamente baseado em subscritos, ainda é para a parte do array da tabela. Novamente com o exemplo color.

$ resty -e 'local color = {first = "red", "blue", third = "green", "yellow"}
print(table.concat(color, ", "))'

Após usar a função table.concat, ela retorna blue, yellow e a parte do hash é ignorada.

Além disso, esta função também pode especificar a posição inicial do subscrito para fazer a concatenação; por exemplo, ela é escrita como a seguir:

$ resty -e 'local color = {first = "red", "blue", third = "green", "yellow", "orange"}
print(table.concat(color, ", ", 2, 3))'

Desta vez, a saída é yellow, orange, pulando blue.

Por favor, não subestime esta função aparentemente inútil, mas ela pode ter efeitos inesperados ao otimizar o desempenho e é uma das principais personagens em nossos capítulos posteriores de otimização de desempenho.

`table.insert` Insere um elemento

Finalmente, vamos olhar para a função table.insert. Ela insere um novo elemento no subscrito especificado, o que afeta a parte do array da tabela. Para ilustrar, novamente usando o exemplo color.

$ resty -e 'local color = {first = "red", "blue", third = "green", "yellow"}
table.insert(color, 1,  "orange")
print(color[1])
'

Você pode ver que o primeiro elemento de color se torna orange, mas, claro, você pode deixar o subscrito não especificado, de modo que ele será inserido no final da fila por padrão.

Devo observar que table.insert é uma operação comum, mas o desempenho não é bom. Se você não estiver inserindo elementos com base no subscrito especificado, precisará chamar lj_tab_len do LuaJIT cada vez para obter o comprimento do array e inserir no final da fila. Como table.getn, a complexidade de tempo para obter o comprimento da tabela é O(n).

Portanto, para a operação table.insert, devemos tentar evitar usá-la em código quente. Por exemplo:

local t = {}
for i = 1, 10000 do
     table.insert(t, i)
end

Funções de extensão da tabela do LuaJIT

A seguir, vamos olhar para as funções de extensão da tabela do LuaJIT. O LuaJIT estende o Lua padrão com duas funções úteis para criar e esvaziar uma tabela, que descreverei abaixo.

`table.new(narray, nhash)` Cria uma nova tabela

A primeira é a função table.new(narray, nhash). Em vez de crescer por si só ao inserir elementos, esta função pré-aloca o tamanho do espaço do array e do hash especificados, que é o que seus dois parâmetros narray e nhash significam. O crescimento automático é uma operação custosa que envolve alocação de espaço, resize e rehash, e deve ser evitado a todo custo.

Observe aqui que a documentação de table.new não está no site do LuaJIT, mas está profundamente na documentação estendida do projeto no GitHub, então é difícil encontrá-la mesmo no Google, e poucos engenheiros sabem disso.

Aqui está um exemplo simples, e vou mostrar como ela funciona. Primeiro, esta função é estendida, então antes de usá-la, você precisa require.

local new_tab = require "table.new"
local t = new_tab(100, 0)
for i = 1, 100 do
   t[i] = i
end

Como você pode ver, este código cria uma nova tabela com 100 elementos de array e 0 elementos de hash. Claro, você pode criar uma nova tabela com 100 elementos de array e 50 elementos de hash, conforme necessário, o que é legal.

local t = new_tab(100, 50)

Alternativamente, se você ultrapassar o tamanho do espaço pré-definido, ainda poderá usá-la normalmente, mas o desempenho será degradado, e o ponto de usar table.new será perdido.

No exemplo a seguir, temos um tamanho pré-definido de 100, mas estamos usando 200.

local new_tab = require "table.new"
local t = new_tab(100, 0)
for i = 1, 200 do
   t[i] = i
end

Você precisa pré-definir o tamanho do espaço do array e do hash em table.new de acordo com o cenário real, para que possa encontrar um equilíbrio entre desempenho e uso de memória.

`table.clear()` Limpa a tabela

A segunda é a função de limpeza table.clear(). Ela limpa todos os dados de uma tabela, mas não libera a memória ocupada pelas partes do array e do hash. Portanto, é útil ao reciclar tabelas Lua para evitar a sobrecarga de criar e destruir tabelas repetidamente.

$ resty -e 'local clear_tab =require "table.clear"
local color = {first = "red", "blue", third = "green", "yellow"}
clear_tab(color)
for k, v in pairs(color) do
     print(k)
end'

No entanto, há poucos cenários onde esta função pode ser usada, e na maioria dos casos, devemos deixar essa tarefa para o GC do LuaJIT.

Funções de extensão da tabela do OpenResty

Como mencionei no início, o OpenResty mantém seu próprio branch do LuaJIT, que também estende a tabela, com várias novas APIs: table.isempty, table.isarray, table.nkeys e table.clone.

Antes de usar essas novas APIs, verifique a versão do OpenResty, pois a maioria dessas APIs só pode ser usada em versões do OpenResty após 1.15.8.1. Isso ocorre porque o OpenResty não teve um novo lançamento por cerca de um ano antes da versão 1.15.8.1, e essas APIs foram adicionadas nesse intervalo de lançamento.

Incluí um link para o artigo, então vou usar table.nkeys como exemplo. As outras três APIs são fáceis de entender a partir da nomenclatura, então dê uma olhada na documentação do GitHub, e você entenderá. Devo dizer que a documentação do OpenResty é de alta qualidade, incluindo exemplos de código, se pode ser JIT, o que observar, etc. Várias ordens de magnitude melhor do que a documentação do Lua e do LuaJIT.

Ok, de volta à função table.nkeys. Sua nomenclatura pode confundir você, mas é uma função que obtém o comprimento da tabela e retorna o número de elementos da tabela, incluindo os elementos do array e da parte do hash. Portanto, podemos usá-la em vez de table.getn, por exemplo, como a seguir.

local nkeys = require "table.nkeys"
print(nkeys({}))  -- 0
print(nkeys({ "a", nil, "b" }))  -- 2
print(nkeys({ dog = 3, cat = 4, bird = nil }))  -- 2
print(nkeys({ "a", dog = 3, cat = 4 }))  -- 3

Metatable

Depois de falar sobre a função da tabela, vamos olhar para a metatable derivada da table. A metatable é um conceito único no Lua e é amplamente usada em projetos reais. Não é exagero dizer que você pode encontrá-la em quase qualquer biblioteca lua-resty-*.

A metatable se comporta como sobrecarga de operadores; por exemplo, podemos sobrecarregar __add para calcular a concatenação de dois arrays Lua ou __tostring para definir funções que convertem para strings.

O Lua, por outro lado, fornece duas funções para lidar com metatable.

A primeira é setmetatable(table, metatable), que configura uma metatable para uma tabela.
A segunda é getmetatable(table), que obtém a metatable da tabela.

Depois de tudo isso, você pode estar mais interessado no que ela faz, então vamos ver para que a metatable é usada especificamente. Aqui está um trecho de código de um projeto real.

$ resty -e ' local version = {
  major = 1,
  minor = 1,
  patch = 1
  }
version = setmetatable(version, {
    __tostring = function(t)
      return string.format("%d.%d.%d", t.major, t.minor, t.patch)
    end
  })
  print(tostring(version))
'

Primeiro definimos uma tabela chamada version, e como você pode ver, o propósito deste código é imprimir o número da versão em version. No entanto, não podemos imprimir version diretamente. Você pode tentar fazer isso e verá que imprimir diretamente só retornará o endereço da tabela.

print(tostring(version))

Portanto, precisamos personalizar a função de conversão de string para esta tabela, que é __tostring, e é aqui que a metatable entra. Usamos setmetatable para redefinir o método __tostring da tabela version para imprimir o número da versão: 1.1.1.

Além de __tostring, frequentemente sobrecarregamos os seguintes dois metamétodos na metatable em projetos reais.

Um deles é __index. Quando procuramos um elemento em uma tabela, primeiro o procuramos diretamente na tabela, e se não o encontrarmos, vamos para o __index da metatable.

No exemplo a seguir, removemos o patch da tabela version.

$ resty -e ' local version = {
  major = 1,
  minor = 1
  }
version = setmetatable(version, {
     __index = function(t, key)
         if key == "patch" then
             return 2
         end
     end,
     __tostring = function(t)
      return string.format("%d.%d.%d", t.major, t.minor, t.patch)
    end
  })
  print(tostring(version))
'

Neste caso, t.patch não obtém o valor, então ele vai para a função __index, que imprime 1.1.2.

__index pode ser não apenas uma função, mas também uma tabela, e se você tentar executar o seguinte código, verá que eles alcançam o mesmo resultado.

$ resty -e ' local version = {
  major = 1,
  minor = 1
  }
version = setmetatable(version, {
     __index = {patch = 2},
     __tostring = function(t)
      return string.format("%d.%d.%d", t.major, t.minor, t.patch)
    end
  })
  print(tostring(version))
'

Outro metamétodo é __call. Ele é semelhante a um functor que permite que uma tabela seja chamada.

Vamos construir sobre o código acima que imprime o número da versão e ver como chamar uma tabela.

$ resty -e '
local version = {
  major = 1,
  minor = 1,
  patch = 1
  }
local function print_version(t)
     print(string.format("%d.%d.%d", t.major, t.minor, t.patch))
end
version = setmetatable(version,
     {__call = print_version})
  version()
'

Neste código, usamos setmetatable para adicionar uma metatable à tabela version, e o metamétodo __call dentro dela aponta para a função print_version. Portanto, se tentarmos chamar version como uma função, a função print_version será executada aqui.

E getmetatable é a operação emparelhada com setmetatable para obter a metatable que foi configurada, como no seguinte código.

$ resty -e ' local version = {
  major = 1,
  minor = 1
  }
version = setmetatable(version, {
     __index = {patch = 2},
     __tostring = function(t)
      return string.format("%d.%d.%d", t.major, t.minor, t.patch)
    end
  })
  print(getmetatable(version).__index.patch)
'

Além desses três metamétodos que discutimos hoje, há alguns metamétodos menos usados que você pode consultar na documentação para aprender mais quando os encontrar.

Orientação a Objetos

Finalmente, vamos falar sobre orientação a objetos. Como você deve saber, o Lua não é uma linguagem de Orientação a Objetos, mas podemos usar metatable para implementar OO.

Vamos ver um exemplo prático. lua-resty-mysql é o cliente MySQL oficial do OpenResty, e ele usa metatables para simular classes e métodos de classe, que são usados da seguinte forma.

    $ resty -e 'local mysql = require "resty.mysql" -- primeiro referencie a biblioteca lua-resty
    local db, err = mysql:new() -- Cria uma nova instância da classe
    db:set_timeout(1000) -- Chamando métodos de uma classe

Você pode executar o código acima diretamente com o comando resty. Essas linhas de código são fáceis de entender; a única coisa que pode causar problemas é:

Por que, ao chamar um método de classe, é usado dois pontos em vez de um ponto?

Na verdade, tanto dois pontos quanto pontos são aceitáveis aqui, e db:set_timeout(1000) e db.set_timeout(db, 1000) são exatamente equivalentes. Os dois pontos são um açúcar sintático no Lua que permite omitir o primeiro argumento self de uma função.

Como todos sabemos, não há segredos diante do código-fonte, então vamos ver a implementação concreta correspondente às linhas de código acima para que você possa entender melhor como modelar orientação a objetos com metatables.

local _M = { _VERSION = '0.21' } -- Usando a tabela para simular uma classe
local mt = { __index = _M } -- mt é abreviação de metatable, __index se refere à própria classe
-- Construtor da classe
function _M.new(self)
    local sock, err = tcp()
    if not sock then
          return nil, err
    end
    return setmetatable({ sock = sock }, mt) -- exemplo de simulação de classes usando tabela e metatable
end

-- Funções membro de uma classe
function _M.set_timeout(self, timeout) -- Use o argumento self para obter uma instância da classe que deseja operar
  local sock = self.sock
  if not sock then
      return nil, "not initialized"
  end

  return sock:settimeout(timeout)
end

A tabela _M simula uma classe inicializada com uma única variável membro _VERSION e posteriormente define funções membro como _M.set_timeout. No construtor _M.new(self), retornamos uma tabela cuja metatable é mt, e o metamétodo __index de mt aponta para _M, de modo que a tabela retornada simula uma instância da classe _M.

Resumo

Bem, isso conclui o conteúdo principal de hoje. Tabela e metatable são amplamente usadas na biblioteca lua-resty-* do OpenResty e em projetos de código aberto baseados no OpenResty. Espero que esta lição facilite a leitura e compreensão do código-fonte.

Há outras funções padrão no Lua além da tabela, que aprenderemos juntos na próxima lição.

Finalmente, gostaria de deixar uma pergunta para reflexão. Por que a biblioteca lua-resty-mysql simula OO como uma camada de encapsulamento? Sinta-se à vontade para discutir esta questão na seção de comentários, e compartilhe este artigo com seus colegas e amigos para que possamos nos comunicar e progredir juntos.

O que são table e metatable em Lua?

As funções da biblioteca table

table.getn Obter o número de elementos

table.remove Remove o elemento especificado

table.concat Função de concatenação de elementos

table.insert Insere um elemento