Lua Academy · Lektion

Deklarera variabler i Lua

Förstå globala och lokala variabler samt namngivningskonventioner.

Lektion 2 av 412 steg

Deklarera variabler i Lua är en gratis lektion i Lua Academy på CoddyKit. Detta är lektion 2 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.

Globala kontra lokala variabler

I Lua är variabler globala som standard. Om Ni skriver x = 10 utan nyckelordet local skapas en global variabel som är åtkomlig överallt. Med local x = 10 begränsas variabeln till det aktuella blocket och dess nästlade block.

Föredra alltid local av prestanda- och säkerhetsskäl. Åtkomst till en lokal variabel går snabbare än åtkomst till en global, eftersom globala variabler kräver en uppslagning i hashtabellen _G.

x = 100          -- global variable
local y = 200    -- local variable

do
  local z = 300  -- block-local
  print(x, y, z) -- 100  200  300
end

print(x, y)      -- 100  200
print(z)         -- nil  (out of scope)

Nyckelordet local

Nyckelordet local deklarerar en variabel med omfång i det närmast omslutande blocket: en funktionskropp, ett do...end-block, en loopkropp eller ett filblock. Lokala variabler skapas på raden där de deklareras och upphör att existera när blocket avslutas.

Ni kan deklarera flera lokala variabler på samma rad och initiera dem samtidigt. Oinitierade lokala variabler får som standard värdet nil.

local a, b, c = 1, 2, 3
print(a, b, c)    -- 1  2  3

local d, e = 10   -- e is nil
print(d, e)       -- 10  nil

local f           -- nil until assigned
f = 42
print(f)          -- 42

Konventioner för variabelnamn

Lu as identifierare följer dessa regler: de måste börja med en bokstav eller ett understreck, följt av bokstäver, siffror eller understreck. Lua är skiftlägeskänsligt, så Value, value och VALUE är tre olika variabler.

Enligt konventionen används camelCase eller snake_case för vanliga variabler, UPPER_CASE för konstanter och ett understreck som prefix för privata modulfält. Undvik namn med en enda bokstav, utom för loopräknare.

local myVariable = 1     -- camelCase
local my_variable = 2    -- snake_case
local MAX_SIZE = 100     -- constant convention
local _private = "hidden" -- private convention

-- Case sensitivity demo
local lua = "lower"
local Lua = "upper"
print(lua, Lua)  -- lower  upper

Den globala tabellen _G

Alla globala variabler i Lua finns i en särskild tabell som heter _G. Att skriva x = 10 motsvarar _G.x = 10. Ni kan granska alla globala variabler genom att iterera över _G, vilket är praktiskt vid felsökning men riskabelt i produktionskod.

I Lua 5.2+ är _ENV den faktiska miljöt abellen och _G initieras till att peka på den. Med denna kunskap kan Ni sandlåda kod genom att ersätta _ENV.

myGlobal = 42
print(_G.myGlobal)   -- 42

-- Setting via _G is the same as direct assignment
_G.another = "hello"
print(another)        -- hello

-- Counting globals (many built-ins exist)
local count = 0
for k in pairs(_G) do count = count + 1 end
print("Globals:", count)

Flera tilldelningar

Lua stöder flera tilldelningar: Ni kan tilldela flera variabler i samma sats. Högerledet utvärderas först och tilldelas sedan från vänster till höger. Om det finns fler variabler än värden får de överblivna nil. Om det finns fler värden än variabler ignoreras de överblivna.

Det gör det enkelt att byta plats på variabler utan en temporär variabel.

-- Swap without temp variable
local a, b = 10, 20
a, b = b, a
print(a, b)   -- 20  10

-- More variables than values
local x, y, z = 1, 2
print(x, y, z)  -- 1  2  nil

-- More values than variables
local p, q = 1, 2, 3  -- 3 is discarded
print(p, q)   -- 1  2

Omfång och blockgränser

Luas blockavgränsare är: do...end, funktionskroppar, if/elseif/else...end, while...end, repeat...until och for...end. Var och en skapar en ny omfångsnivå. do...end-block är användbara enbart för att begränsa omfånget utan någon annan logik.

En lokal variabel som deklareras i huvudet på en for-loop har omfång i loopkroppen — den läcker inte utanför.

for i = 1, 3 do
  local msg = "item " .. i
  print(msg)
end
-- print(i)   -- would be nil, i is gone
-- print(msg) -- would be nil, msg is gone

-- do...end for manual scoping
do
  local temp = expensive_computation or 0
  print(temp)
end
-- temp is nil here

Konstanter: Konventionen local

Lua har inget inbyggt nyckelord const. Konventionen är att använda namn med UPPER_CASE och local för att visa att ett värde inte bör ändras. Om konstanter placeras högst upp i en modul som lokala variabler får JIT-kompilatorn dessutom en ledtråd om att dessa värden är stabila.

För verklig oföränderlighet kan Ni använda en proxytabell med __newindex som utlöser ett fel vid ändringar — detta går vi igenom i lektionen om metatabeller.

local MAX_RETRIES = 3
local PI = 3.14159265358979
local APP_VERSION = "1.0.0"

-- Use them as read-only by convention
local area = PI * 5 * 5
print(area)           -- 78.539...
print(MAX_RETRIES)    -- 3

Variabelskuggning

Skuggning uppstår när ett inre omfång deklarerar en lokal variabel med samma namn som en variabel i ett yttre omfång. Den inre deklarationen skapar en helt ny variabel som döljer den yttre inom sitt omfång. Den yttre variabeln ändras inte och blir synlig igen när det inre omfånget avslutas.

Skuggning kan vara förvirrande. Föredra unika namn i nästlade omfång, men ibland är det avsiktligt, till exempel när loopvariabelnamn återanvänds i nästlade loopar.

local x = "outer"
do
  local x = "inner"  -- shadows outer x
  print(x)            -- inner
end
print(x)              -- outer (unchanged)

local n = 10
for n = 1, 3 do       -- loop n shadows outer n
  print(n)            -- 1, 2, 3
end
print(n)              -- 10 (outer unchanged)

Undvika global nedskräpning

Oavsiktliga globala variabler är ett vanligt Lua-fel: om Ni stavar fel på namnet till en lokal variabel skapas en ny global variabel utan varning. Modulen strict.lua, som ofta inkluderas i projekt, upptäcker läsning och skrivning av odeklarerade globala variabler genom att lägga till en metatabell i _G.

Ett enklare sätt är att alltid använda local och köra luac -p eller en linter som luacheck för att upptäcka oavsiktliga globala variabler före körning.

-- Dangerous: typo creates a global silently
local counter = 0
coutner = 5  -- typo! creates global 'coutner'
print(counter)  -- 0 (not 5!)
print(coutner)  -- 5 (the typo global)

-- Fix: always use local keyword
local score = 0
score = 10  -- assigns to existing local
print(score) -- 10

Tilldelning av nil tar bort globala variabler

Om Ni sätter en global variabel till nil tas den bort från _G, vilket frigör minne. Detta är det korrekta sättet att ”ta bort” en global variabel. För lokala variabler räcker det att låta dem lämna sitt omfång — skräpsamlaren återtar minnet.

Var försiktig när Ni skickar med nil vid flera tilldelningar: i vissa sammanhang kan det förkorta argumentlistan, särskilt med funktionsanrop på högerledet.

myGlobal = "exists"
print(myGlobal)   -- exists
print(_G.myGlobal ~= nil)  -- true

myGlobal = nil
print(myGlobal)   -- nil
print(_G.myGlobal ~= nil)  -- false
-- The entry is removed from _G

Snabb kontroll

Vilket omfång har en variabel som deklareras med local x = 5 inuti en for-loopkropp?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Deklarera variabler i Lua

Viktiga slutsatser från lektionen:

Variabler är globala som standard — använd alltid local
Lokala variabler är snabbare (ingen hashuppslagning) och säkrare
Flera tilldelningar: a, b = b, a byter plats på en rad
Alla globala variabler finns i _G; om de sätts till nil tas de bort
Skuggning: en inre local döljer den yttre variabeln utan att ändra den
Använd enligt konventionen UPPER_CASE för konstanter

Nästa steg: aritmetiska, relationella och logiska operatorer.

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 ”Deklarera variabler i Lua” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lua Academy, inklusive ”Deklarera variabler i Lua”, 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 ”Deklarera variabler i Lua”?

Förstå globala och lokala variabler samt namngivningskonventioner. 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 2 av 4.

Hur lång tid tar lektionen ”Deklarera variabler i Lua”?

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