Lua Academy · Lección

Detección y carga de plugins

Busque archivos de plugins en directorios y cárguelos con require o loadfile.

Detección y carga de plugins es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Lua Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Lua Academy incluye 4 lecciones en total.

¿Qué es una arquitectura de plugins?

Una arquitectura de plugins permite que el código de terceros amplíe una aplicación sin modificar su núcleo. require y la carga dinámica de Lua hacen que este enfoque resulte natural.

Descubrimiento de plugins por convención

Explore un directorio en busca de archivos *.lua que coincidan con una convención de nombres y, después, cargue cada uno como plugin.

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

Uso de package.path para el descubrimiento

Amplíe package.path para que require pueda encontrar plugins en un directorio personalizado.

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

loadfile para la carga dinámica

loadfile(path) compila un archivo Lua en un chunk sin ejecutarlo. Ejecútelo con () para obtener la tabla del módulo del plugin.

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

Manifiesto del plugin

Cada plugin exporta una tabla de manifiesto que describe su nombre, versión y dependencias.

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

Resolución de dependencias

Antes de inicializar un plugin, compruebe que todas sus dependencias ya estén cargadas.

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 en caliente de plugins

Para recargar un plugin: elimínelo de package.loaded, vuelva a cargarlo con require y vuelva a registrar los hooks.

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

Registro de plugins

Mantenga un registro de los plugins cargados para evitar cargarlos dos veces y permitir la comprobación de dependencias.

Aislamiento de errores

Cargue los plugins con pcall para que un plugin defectuoso no bloquee toda la aplicación.

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

Metadatos del plugin

Almacene metadatos adicionales: descripción, autor y esquema de configuración. Utilícelos para mostrarlos en la interfaz o configurar automáticamente el plugin.

Carga diferida

Cargue los plugins solo cuando se necesiten por primera vez, en lugar de cargarlos de forma anticipada al iniciar la aplicación. Impleméntela mediante una tabla proxy con un metamétodo __index que active la carga.

Pregunta sobre la carga de plugins

¿Cuál es la ventaja de utilizar pcall al cargar plugins?

Repaso: descubrimiento y carga de plugins

Descubra plugins explorando directorios o utilizando convenciones de nombres. Cárguelos con loadfile o require. Valide los manifiestos y resuelva las dependencias. Utilice siempre pcall para aislar los fallos de carga.

Preguntas frecuentes

¿La lección «Detección y carga de plugins» es gratis?

Sí — el texto completo de «Detección y carga de plugins» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Lua Academy, actualiza a CoddyKit PRO. El curso de Lua Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Detección y carga de plugins»?

Busque archivos de plugins en directorios y cárguelos con require o loadfile. Practicas Lua Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Lua Academy?

No se requiere experiencia previa. Lua Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Detección y carga de plugins»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Lua Academy?

Sí. Cada lección de Lua Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Lua Academy