Lua Academy · Aula

Descoberta e carregamento de plugins

Examine diretórios em busca de arquivos de plugins e carregue-os com require ou loadfile.

Aula 1 de 413 etapas

Descoberta e carregamento de plugins é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Lua Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Lua Academy inclui 4 aulas no total.

O que é uma arquitetura de extensões?

Uma arquitetura de extensões permite que código de terceiros amplie um aplicativo sem modificar seu núcleo. O require e o carregamento dinâmico do Lua tornam isso natural.

Descoberta de extensões por convenção

Examine um diretório em busca de arquivos *.lua que correspondam a uma convenção de nomes e, em seguida, carregue cada um como uma extensão.

local function discoverPlugins(dir)
  local plugins = {}
  -- platform-specific dir scan; here a mock example
  for _, name in ipairs({"logger", "cache", "auth"}) do
    local ok, mod = pcall(require, dir .. "." .. name)
    if ok then plugins[name] = mod end
  end
  return plugins
end

Usando package.path para descoberta

Amplie package.path para que require possa encontrar extensões em um diretório personalizado.

package.path = package.path .. ";./plugins/?.lua"
local plugin = require("myplugin")

loadfile para carregamento dinâmico

loadfile(path) compila um arquivo Lua em um bloco sem executá-lo. Execute-o com () para obter a tabela do módulo da extensão.

local function loadPlugin(path)
  local chunk, err = loadfile(path)
  if not chunk then return nil, err end
  local ok, result = pcall(chunk)
  if not ok then return nil, result end
  return result
end

Manifesto de extensão

Cada extensão exporta uma tabela de manifesto que descreve seu nome, sua versão e suas dependências.

-- plugins/logger.lua
return {
  name    = "logger",
  version = "1.0",
  deps    = {},
  init    = function(app) app:on("log", print) end,
}

Resolução de dependências

Antes de inicializar uma extensão, verifique se todas as suas dependências já foram carregadas.

local function initPlugin(app, plugins, name)
  local p = plugins[name]
  if not p then error("Plugin not found: " .. name) end
  for _, dep in ipairs(p.deps or {}) do
    if not plugins[dep] then
      error(("Plugin %s requires %s"):format(name, dep))
    end
  end
  if p.init then p.init(app) end
end

Recarga a quente de extensões

Para recarregar uma extensão: remova-a de package.loaded, recarregue-a com require e registre novamente os ganchos.

package.loaded["plugins.logger"] = nil
plugins.logger = require("plugins.logger")
plugins.logger.init(app)

Registro de extensões

Mantenha um registro das extensões carregadas para evitar carregamentos duplicados e permitir a verificação de dependências.

Isolamento de erros

Carregue extensões com pcall para que uma extensão com falha não faça o aplicativo inteiro parar.

local ok, err = pcall(function()
  plugins[name] = loadPlugin(path)
  initPlugin(app, plugins, name)
end)
if not ok then
  print("Plugin load failed:", name, err)
end

Metadados de extensões

Armazene metadados adicionais: descrição, autor e esquema de configuração. Use-os para exibição na interface ou configuração automática.

Carregamento sob demanda

Carregue extensões somente quando forem necessárias pela primeira vez, em vez de carregá-las antecipadamente na inicialização. Implemente isso usando uma tabela de intermediação com um metamétodo __index que aciona o carregamento.

Pergunta sobre carregamento de extensões

Qual é a vantagem de usar pcall ao carregar extensões?

Responda na aula interativa

Recapitulação: descoberta e carregamento de extensões

Descubra extensões examinando diretórios ou usando convenções de nomes. Carregue-as com loadfile ou require. Valide os manifestos e resolva as dependências. Use sempre pcall para isolar falhas de carregamento.

Grátis para começar

Aprenda Lua com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 40
Aulas: 159

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Descoberta e carregamento de plugins” é grátis?

Sim — o texto completo de “Descoberta e carregamento de plugins” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Lua Academy, atualize para CoddyKit PRO. O curso de Lua Academy inclui 4 aulas no total.

O que vou aprender em “Descoberta e carregamento de plugins”?

Examine diretórios em busca de arquivos de plugins e carregue-os com require ou loadfile. Você pratica Lua Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Lua Academy?

Nenhuma experiência prévia é necessária. Lua Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Descoberta e carregamento de plugins”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Lua Academy?

Sim. Cada aula de Lua Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Descoberta e carregamento de plugins
API de plugins e sistema de hooks
Execução isolada de plugins
Versionamento e gerenciamento de dependências

← Voltar para Lua Academy