Lua-sheriffen, del 3- Tables

Då var det dags för ett nytt avsnitt om Lua-programmering!

Förra veckan tittade vi på Stränghantering, men idag ska vi gå igenom den enda egentliga avancerade datatypen i Lua: Tables (eller tabeller)!

Tabeller påminner om arrayer, men med skillnaden att man kan stoppa i godtycklig data. Lua bryr sig med andra ord inte om man blandar exempelvis heltal och strängar. För att skapa och modifiera en table kan man göra som följer (kom ihåg att en online-interpreterare för att testa kodsnuttar med finns här):

-- Skapa en table
a = {}

-- Sätt position '1' till "b"
a[1] = "b"

En skillnad mot många andra språk är att man i Lua kan ange vilken position man vill. I C är det annars heltal från 0 och uppåt, men i Lua går det lika bra med negativa tal, även om Lua-standard är att använda heltal från 1 och uppåt. Det går också att använda något annat, exempelvis strängar, så man kan lika gärna skriva a[“a”] = “b” och det kommer gå lika bra! Tokigt språk, eller hur?

Vad kan man då använda detta till? Man kan lagra en lista med tal eller strängar, för att nämna något enkelt. I och med att man kan använda vilken typ av data som helst kan man också smidigt göra “Dictionaries” eller göra en lista av objekt. Några exempel:

-- En dictionary, i detta fall engelska till svenska
dict = {}
dict["hello"] = "hej"

print(dict["hello"])

-- Detta gör samma sak som printkommandot ovan
print(dict.hello)

-- Ta bort referensen till dictionary, som då automatiskt raderas ur minnet
dictionary = nil

 Sekvens

Om en table är indexerad med heltal från 1 och uppåt och inte har några “hål” (dvs alla positioner mellan första och sista heltalet man använder är fyllda) kallas tablen för en “sekvens”. En fördel med sekvenser är att man kan skriva följande för att hämta ut sekvensens längd:

a = {}
for i=1, 5 do
 a[i] = "data"
end

print (#a)

for i=1, #a do
 print(a[i])
end

Här skapar vi, med hjälp av en for-loop, en sekvens med fem element, som alla är likadana. Sen skriver vi ut sekvensens längd med print(#a), och till sist skriver vi ut innehållet på alla positioner i sekvensen. Notera i den andra loopen hur vi använder längden på ‘a’ istället för att “hårdkoda” in 5. Så länge man håller sig till sekvenser är tables som synes väldigt smidiga att arbeta med då man inte behöver definiera längden utan kan hämta ut den enkelt vid behov.

Vanliga fel

När man programmerar Lua är det lätt hänt att man råkar försöka använda en sträng för att komma åt data i en sekvens. För att undvika detta kan man använda funktionen “tonumber()” för att försäkra sig om att den data man skickar in är heltal:

a = {}
a[1] = "hejsan"

a["1"] = "hej"

print(a[1])
print(a["1"])

print(a[tonumber("1")])

Ett annat problem, som egentligen inte är ett problem men som kan vara bra att tänka på, är att man kan använda sig av 0 och även negativa tal som index när man lägger till data i en sekvens. När man använder sig av #sekvens så räknas däremot bara elementen från 1 och framåt, så har du råkat fylla i 0 eller ett negativt tal någonstans när sekvensen skapats så kommer dessa element inte att “synas” korrekt för språket.

 Så vad har vi lärt oss idag?

• Vad en table är, samt vad en sekvens är och vad som utmärker dessa
• Hur man skapar, och lägger till data till, en table
• Hur man kontrollerar och använder sig av längden av en sekvens
• Vad man bör tänka på för att undvika svårfunna fel relaterade till tables

Slut för idag, tack för idag! Nästa gång ska vi titta på funktioner och hur man kan definiera objekt i Lua! Ses då!