Lua Academy · Lektion

Paketera ett plugin-program

Strukturera och dela det.

Lektion 4 av 413 steg

Paketera ett plugin-program är en gratis lektion i Lua Academy på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lua Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lua Academy innehåller totalt 4 lektioner.

Pluginets katalogstruktur

Ett Neovim-plugin är helt enkelt en katalog på runtimepath. Den konventionella strukturen har mappar på toppnivå som Neovim behandlar på särskilda sätt.

Viktiga kataloger: lua/ för moduler, plugin/ för automatiskt inläst initiering, ftplugin/ för filtypsskript, doc/ för hjälp och after/ för sena åsidosättningar.

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

Katalogen lua/

Filer under lua/ kan nås med require. En modul på lua/myplugin/init.lua läses in som require('myplugin').

Kapsling motsvarar punktseparerade sökvägar: lua/myplugin/config.lua blir require('myplugin.config'). Det är så plugins exponerar en ren offentlig namnrymd.

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

Returnera en modultabell

Det idiomatiska modulmönstret deklarerar en lokal tabell M, kopplar funktioner till den och returnerar den. Anropare kan sedan använda require('myplugin').hello().

Behåll interna hjälpfunktioner som vanliga lokala funktioner så att endast det avsedda gränssnittet är offentligt. Detta motsvarar modulinkapsling i andra ekosystem.

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

Konventionen för setup()

De flesta plugins exponerar en setup(opts)-funktion. Den slår ihop användarens alternativ med standardvärdena och utför initiering, till exempel genom att skapa kommandon och autokommandon.

Använd vim.tbl_deep_extend('force', defaults, opts or {}) så att en delvis angiven användarkonfiguration ändå får alla standardvärden.

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

Katalogen plugin/

Skript i plugin/ körs automatiskt när Neovim startar, efter att runtimepath har byggts upp. Håll dem små.

En vanlig uppgift är att registrera kommandon eller ett skydd som gör att tunga moduler läses in först vid behov. Undvik kostsamt arbete här; skjut upp det till setup eller autokommandon för att hålla uppstarten snabb.

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

Laddningsskydd

Ett laddningsskydd förhindrar dubbel initiering om filen läses in två gånger. Sätt en vim.g.loaded_*-flagga och avsluta tidigt om filen läses in igen.

Detta är viktigt eftersom pluginhanterare och :runtime kan läsa in filer igen, och dubbla kommandon eller autokommandon orsakar svårupptäckta fel.

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

Lazy loading

Snabb uppstart innebär att kod bara läses in när den behövs. Registrera ett lättviktigt kommando i plugin/ som kräver den tunga modulen första gången det används.

Pluginhanterare som lazy.nvim formaliserar detta med utlösare för cmd, ft och keys, så att modulen inte berörs förrän den aktiveras.

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

runtimepath och packpath

Neovim hittar plugins genom att söka igenom runtimepath. Det inbyggda paketsystemet läser automatiskt in kataloger under pack/*/start/ och kataloger under pack/*/opt/ på begäran via :packadd.

De flesta användare förlitar sig på en pluginhanterare, men om du förstår runtimepath blir det tydligt hur dina mappar hittas.

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

Hälsokontroller

Skapa en lua/myplugin/health.lua med en check-funktion så att användare kan köra :checkhealth myplugin. Rapportera status med API:et vim.health.

Använd vim.health.start, vim.health.ok, vim.health.warn och vim.health.error för att tydligt visa saknade beroenden.

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

Dokumentation och taggar

Leverera en hjälpfil på doc/myplugin.txt. Kör :helptags doc/ (eller låt pluginhanteraren göra det) för att generera taggindexet så att :help myplugin fungerar.

Bra dokumentation listar kommandon, alternativen för setup och standardmappningar för tangenter, vilket gör pluginet lätt att hitta inifrån Neovim.

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

Versionshantering och publicering

Värdhosta pluginet i ett git-repository; användare installerar det via sökvägen owner/repo. Tagga utgåvor enligt semantisk versionshantering så att pluginhanterare kan låsa versioner.

Inkludera en README med installationssnuttar för populära pluginhanterare, en licens och ett minimalt konfigurationsexempel för att sänka tröskeln för användning.

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

Snabbtest

Bekräfta att du har förstått hur plugins paketeras.

Besvara frågan i den interaktiva lektionen

Sammanfattning: Paketera ett plugin

Ett plugin är en katalog på runtimepath med moduler i lua/, ett automatiskt körbart skript i plugin/ och valfria kataloger för doc/, ftplugin/ samt hälsokontrollfiler.

Returnera modultabeller, exponera en setup som slår ihop standardvärden, förhindra dubbel inläsning, läs in tung kod först vid behov, dokumentera med helptags och publicera via git med semantiska versionstaggar.

Gratis att börja

Lär dig Lua med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 40
Lektioner: 159

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Paketera ett plugin-program” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lua Academy, inklusive ”Paketera ett plugin-program”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lua Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Paketera ett plugin-program”?

Strukturera och dela det. Ni övar på Lua Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Lua Academy?

Du behöver inga förkunskaper. Utbildningen i Lua Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Paketera ett plugin-program”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Lua Academy-lektionen?

Ja. Varje Lua Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Lua Academy