Lua Academy · Les

Een plugin verpakken

Structureer en deel de plugin.

Les 4 van 413 stappen

Een plugin verpakken is een gratis Lua Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Lua Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Lua Academy bevat in totaal 4 lessen.

Mapstructuur van een plug-in

Een Neovim-plug-in is gewoon een map op het runtimepath. De standaardindeling heeft mappen op het hoogste niveau die Neovim speciaal behandelt.

Belangrijke mappen zijn: lua/ voor modules, plugin/ voor automatisch geladen configuratie, ftplugin/ voor scripts voor bestandstypen, doc/ voor helpteksten en after/ voor late overschrijvingen.

-- myplugin/
--   lua/myplugin/init.lua
--   plugin/myplugin.lua
--   doc/myplugin.txt

De lua/-map

Bestanden onder lua/ zijn bereikbaar via require. Een module op lua/myplugin/init.lua wordt geladen als require('myplugin').

Nesten wordt omgezet in paden met punten: lua/myplugin/config.lua wordt require('myplugin.config'). Zo stellen plug-ins een nette openbare naamruimte beschikbaar.

-- in lua/myplugin/init.lua
local M = {}
function M.hello() print('hi') end
return M

Een moduletabel retourneren

Het gebruikelijke modulepatroon declareert een lokale tabel M, voegt functies toe en retourneert de tabel. Aanroepers krijgen vervolgens toegang tot require('myplugin').hello().

Houd interne hulpfuncties als gewone lokale waarden, zodat alleen het bedoelde oppervlak openbaar is. Dit lijkt op module-inkapseling in andere ecosystemen.

local M = {}
local function private() end
function M.run() private() end
return M

De conventie voor setup()

De meeste plug-ins stellen een functie setup(opts) beschikbaar. Die combineert gebruikersopties met standaardwaarden, waarbij de gebruikersopties voorgaan, en voert initialisatie uit, zoals het aanmaken van opdrachten en automatische opdrachten.

Gebruik vim.tbl_deep_extend('force', defaults, opts or {}), zodat een gedeeltelijke gebruikersconfiguratie nog steeds alle standaardwaarden krijgt.

local M = {}
local defaults = { width = 40 }
function M.setup(opts)
  M.config = vim.tbl_deep_extend('force', defaults, opts or {})
end
return M

De plugin/-map

Scripts in plugin/ worden automatisch uitgevoerd wanneer Neovim start, nadat runtimepath is opgebouwd. Houd ze klein.

Een veelvoorkomende taak is het registreren van opdrachten of een beveiliging, zodat zware modules lui worden geladen. Vermijd hier duur werk; stel het uit tot setup of automatische opdrachten om het opstarten snel te houden.

-- in plugin/myplugin.lua
if vim.g.loaded_myplugin then return end
vim.g.loaded_myplugin = true

Beveiliging tegen dubbel laden

Een laadbeveiliging voorkomt dubbele initialisatie als het bestand tweemaal wordt ingelezen. Stel een vlag vim.g.loaded_* in en stop vroegtijdig wanneer het bestand opnieuw wordt ingelezen.

Dit is essentieel omdat plug-inbeheerders en :runtime bestanden opnieuw kunnen inlezen. Dubbele opdrachten of automatische opdrachten veroorzaken subtiele fouten.

if vim.g.loaded_myplugin == 1 then return end
vim.g.loaded_myplugin = 1

Lui laden

Snel opstarten betekent dat je code alleen laadt wanneer dat nodig is. Registreer in plugin/ een lichte opdracht die de zware module bij het eerste gebruik vereist.

Plug-inbeheerders zoals lazy.nvim werken dit uit met triggers voor cmd, ft en keys, zodat je module pas wordt aangeraakt wanneer die wordt aangeroepen.

vim.api.nvim_create_user_command('MyStart', function()
  require('myplugin').run()
end, {})

runtimepath en packpath

Neovim ontdekt plug-ins door runtimepath te scannen. Het eigen pakketsysteem laadt mappen onder pack/*/start/ automatisch en mappen onder pack/*/opt/ op aanvraag via :packadd.

De meeste gebruikers vertrouwen op een beheerder, maar als je runtimepath begrijpt, weet je hoe je mappen worden gevonden.

print(vim.o.runtimepath:sub(1, 60))
-- :packadd loads an opt plugin manually

Gezondheidscontroles

Maak een lua/myplugin/health.lua met een functie check, zodat gebruikers :checkhealth myplugin kunnen uitvoeren. Rapporteer de status met de API vim.health.

Gebruik vim.health.start, vim.health.ok, vim.health.warn en vim.health.error om ontbrekende afhankelijkheden duidelijk zichtbaar te maken.

local M = {}
function M.check()
  vim.health.start('myplugin')
  vim.health.ok('all good')
end
return M

Documentatie en tags

Lever een helpbestand doc/myplugin.txt. Voer :helptags doc/ uit, of laat de beheerder dit doen, om de tagindex te genereren, zodat :help myplugin werkt.

Goede documentatie vermeldt opdrachten, de opties van setup en standaardtoetsencombinaties, zodat je plug-in vanuit Neovim goed vindbaar is.

-- generate tags from the doc directory
vim.cmd('helptags ' .. vim.fn.expand('%:p:h'))

Versiebeheer en publiceren

Host de plug-in in een git-opslagplaats; gebruikers installeren die via het pad owner/repo. Voorzie releases van semantische versietags, zodat beheerders versies kunnen vastzetten.

Voeg een README toe met installatievoorbeelden voor populaire beheerders, een licentie en een minimaal configuratievoorbeeld om de drempel voor gebruik te verlagen.

-- lazy.nvim spec
-- { 'owner/myplugin', config = function()
--     require('myplugin').setup({})
--   end }

Korte controle

Controleer of je begrijpt hoe het verpakken van plug-ins werkt.

Beantwoord dit in de interactieve les

Samenvatting: een plug-in verpakken

Een plug-in is een map op het runtimepath met modules in lua/, een automatisch uitgevoerd script in plugin/ en optionele bestanden in doc/, ftplugin/ en voor gezondheidscontroles.

Retourneer moduletabellen, stel een setup beschikbaar die standaardwaarden samenvoegt, voorkom dubbel laden, laad zware code lui, documenteer met helptags en publiceer via git met tags voor semantische versies.

Gratis beginnen

Leer Lua met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 40
Lessen: 159

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Een plugin verpakken” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Lua Academy, waaronder “Een plugin verpakken”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Lua Academy bevat in totaal 4 lessen.

Wat leer ik in “Een plugin verpakken”?

Structureer en deel de plugin. Je oefent met Lua Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Lua Academy te beginnen?

Ervaring vooraf is niet nodig. Lua Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Een plugin verpakken”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Lua Academy?

Ja. Elke les over Lua Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Lua Academy