Lua Academy · Lektion

Översikt över Luas datatyper

Utforska typerna nil, boolean, number, string, table, function och userdata.

Lektion 1 av 412 steg

Översikt över Luas datatyper är en gratis lektion i Lua Academy på CoddyKit. Detta är lektion 1 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.

Välkommen till Lua

Lua är ett lättviktigt, snabbt och inbäddningsbart skriptspråk som används i spelmotorer, webbservrar och inbyggda system. Innan Ni skriver riktiga program behöver Ni förstå hur Lua representerar data.

Lua har 8 grundläggande typer: nil, boolean, number, string, table, function, userdata och thread. Varje värde i Lua tillhör exakt en av dessa typer.

-- Check the type of any value with type()
print(type(42))        -- number
print(type("hello"))   -- string
print(type(true))      -- boolean
print(type(nil))       -- nil

nil: Frånvaro av värde

nil är L uas sätt att representera ingenting eller inget värde. Det är det enda värdet av sin typ. Variabler som aldrig har tilldelats något innehåller automatiskt nil.

Om Ni tilldelar nil till en global variabel tas den i praktiken bort. I tabeller tar en tilldelning av nil till en nyckel bort den posten helt.

-- Unassigned variables are nil
print(x)          -- nil

x = 10
print(x)          -- 10

x = nil
print(x)          -- nil (variable is gone)

boolean: true och false

Typen boolean har exakt två värden: true och false. Lua har enkla men viktiga regler för sanningsvärden: endast nil och false är falska. Allt annat — inklusive talet 0 och den tomma strängen "" — är sant.

Detta skiljer sig från många språk där 0 eller "" betraktas som falska.

-- Lua truthiness examples
if 0 then print("0 is truthy!") end       -- prints!
if "" then print("empty str is truthy!") end -- prints!
if nil then print("nil") else print("nil is falsy") end
if false then print("false") else print("false is falsy") end

number: Heltal och flyttal

Lua 5.3+ har två undertyper av number: integer och float. Heltal är exakta 64-bitarsvärden och flyttal använder IEEE 754 med dubbel precision. I Lua 5.1/5.2 är alla tal double-värden.

Funktionen math.type() skiljer mellan de två undertyperna. Division med / returnerar alltid ett flyttal; // (heltalsdivision med avrundning nedåt) returnerar ett heltal när båda operanderna är heltal.

print(type(10))       -- number
print(type(10.5))     -- number
print(math.type(10))  -- integer
print(math.type(10.5))-- float
print(10 / 3)         -- 3.3333...
print(10 // 3)        -- 3  (floor division)

string: Text i Lua

Strängar i Lua är oföränderliga sekvenser av byte. Ni kan avgränsa dem med enkla eller dubbla citationstecken, eller med långa hakparenteser [[...]] för flerradiga strängar. Strängar med långa hakparenteser ignorerar den första radbrytningen och bevarar allt annat ordagrant.

Lua-strängar internieras, så identiska strängar delar minne. Längdoperatorn # returnerar antalet byte.

local s1 = 'single quotes'
local s2 = "double quotes"
local s3 = [[multi-line
long string]]

print(#s1)           -- 13
print(type(s1))      -- string
print(s1 .. " works") -- concatenation with ..

table: Den universella behållaren

Typen table är Luas enda sammansatta datastruktur, men den är tillräckligt kraftfull för att implementera arrayer, lexikon, objekt, mängder med mera. Tabeller är associativa arrayer: de mappar nycklar till värden, där nycklar kan vara vilka värden som helst utom nil och NaN.

Tabeller skapas med klammerparenteser {}. Arrayliknande tabeller använder heltalsnycklar som börjar på 1.

-- Array style
local fruits = {"apple", "banana", "cherry"}
print(fruits[1])   -- apple (1-indexed!)

-- Dictionary style
local person = {name = "Alice", age = 30}
print(person.name) -- Alice
print(person["age"]) -- 30

function: Förstavärdesfunktioner

Funktioner i Lua är förstavärden av typen function. De kan lagras i variabler, skickas som argument och returneras från andra funktioner. Därför lämpar sig Lua naturligt för funktionella programmeringsmönster.

Ni kan definiera funktioner med nyckelordet function eller tilldela anonyma funktioner till variabler. Båda formerna är likvärdiga.

-- Two equivalent ways to define a function
function greet(name)
  return "Hello, " .. name
end

local greet2 = function(name)
  return "Hello, " .. name
end

print(type(greet))   -- function
print(greet("Lua"))  -- Hello, Lua

userdata och thread

userdata representerar godtyckliga C-data som hanteras av värdapplikationen. Ni kan inte skapa userdata i ren Lua — det kommer från C-tillägg eller inbäddningsmiljöer som spelmotorer. Det gör det möjligt för C-kod att exponera objekt för Lua-skript.

thread representerar korutiner — oberoende exekveringstrådar med egna stackar. Vi går igenom korutiner i en separat lektion. För tillfället räcker det att känna till att coroutine.create() returnerar ett värde av typen thread.

-- thread type via coroutine
local co = coroutine.create(function()
  print("coroutine body")
end)

print(type(co))  -- thread

-- userdata comes from C, not creatable in pure Lua
-- type(io.stdin) == "file" is a userdata variant

Använda type() för att granska värden

Den inbyggda funktionen type() returnerar alltid en sträng som anger typen för sitt argument. Detta är användbart vid defensiv programmering och felsökning. Ni kan jämföra resultatet direkt med strängarna som anger typnamn.

Observera att type(nil) returnerar strängen "nil", inte själva värdet nil. På så sätt kan Ni säkert kontrollera om en variabel innehåller nil utan att fel uppstår.

local values = {42, "hi", true, nil, {}, function() end}

-- Note: nil in table stops ipairs early
for i = 1, 3 do
  print(i, type(values[i]))
end
-- 1  number
-- 2  string
-- 3  boolean

Skillnader i typer jämfört med andra språk

Om Ni kommer från JavaScript, Python eller Java kan vissa typregler i Lua överraska Er. Det finns ingen separat heltalstyp som type() visar — både heltal och flyttal returnerar "number". Arrayer har ingen egen typ — de är helt enkelt tabeller. Klasser finns inte — objekt är tabeller med metatabeller.

Om Ni förstår dessa skillnader förebygger Ni vanliga fel när Ni byter mellan språk.

-- No separate array type
local arr = {1, 2, 3}
print(type(arr))      -- table (not array!)

-- No separate integer type visible
print(type(1))        -- number
print(type(1.0))      -- number

-- math.type distinguishes
print(math.type(1))   -- integer
print(math.type(1.0)) -- float

Snabb kontroll

Vad returnerar type(0) i Lua?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Översikt över Luas datatyper

Ni har lärt Er alla 8 Lua-typer:

nil — frånvaro av värde; falskt
boolean — true/false; endast nil och false är falska
number — heltal eller flyttal; använd math.type() för att skilja dem åt
string — oföränderliga bytesekvenser; använd .. för att sammanfoga
table — den universella behållaren för arrayer och lexikon
function — förstavärden som kan lagras i variabler
userdata — C-data som exponeras för Lua
thread — korutinreferenser

Nästa steg: deklarera variabler — globalt kontra lokalt omfång.

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 ”Översikt över Luas datatyper” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lua Academy, inklusive ”Översikt över Luas datatyper”, 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 ”Översikt över Luas datatyper”?

Utforska typerna nil, boolean, number, string, table, function och userdata. 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 1 av 4.

Hur lång tid tar lektionen ”Översikt över Luas datatyper”?

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