Operatoren

Objekte können auch mit Operatoren arbeiten. Normalerweise fragt == zwischen zwei Tabellen, ob es dieselbe Tabelle ist (wie du in der Lektion über Tabellen als Dictionaries gesehen hast, ist {} == {} gleich false), und < oder + zwischen Tabellen endet mit einem Fehler. Mit Metamethoden entscheidest du, was diese Operatoren mit deinen Objekten tun. Hier ist eine Klasse für Säcke mit geernteten Pflanzen:

local Sack = {}
Sack.__index = Sack

function Sack.new(pflanze, kg)
    local sack = {pflanze = pflanze, kg = kg}
    setmetatable(sack, Sack)
    return sack
end

function Sack:__tostring()
    return self.pflanze .. ": " .. self.kg .. " kg"
end

function Sack.__add(a, b)
    return Sack.new(a.pflanze, a.kg + b.kg)
end

function Sack.__eq(a, b)
    return a.pflanze == b.pflanze and a.kg == b.kg
end

function Sack.__lt(a, b)
    return a.kg < b.kg
end

local kartoffeln = Sack.new("Kartoffel", 20)
local mehrKartoffeln = Sack.new("Kartoffel", 15)
local karotten = Sack.new("Karotte", 20)

print(kartoffeln + mehrKartoffeln)
print(kartoffeln == karotten, kartoffeln == Sack.new("Kartoffel", 20))
print(mehrKartoffeln < kartoffeln, mehrKartoffeln > kartoffeln)

local saecke = {Sack.new("Kürbis", 40), karotten, mehrKartoffeln}
table.sort(saecke)
for _, sack in ipairs(saecke) do
    print(sack)
end

Das gibt Folgendes aus:

Kartoffel: 35 kg
false	true
true	false
Kartoffel: 15 kg
Karotte: 20 kg
Kürbis: 40 kg

Die Metamethode eines Operators bekommt beide Seiten, a von links und b von rechts, und das Ergebnis des Operators ist, was sie zurückgibt. Deshalb werden diese Metamethoden mit einem Punkt und zwei Parametern definiert: Beide Seiten sind gleichberechtigt. (function Sack:__lt(other), mit self links und other rechts, wäre dieselbe Funktion.)

• __add ist +. kartoffeln + mehrKartoffeln ruft Sack.__add(kartoffeln, mehrKartoffeln) auf, was einen neuen Sack mit 35 kg zurückgibt; keiner der beiden Säcke ändert sich. Die anderen funktionieren genauso: __sub für -, __mul für *, __div für /.
• __eq ist == (und ~=, sein Gegenteil). Hier sind zwei Säcke gleich, wenn sie dieselbe Pflanze enthalten und gleich viel wiegen, auch wenn es verschiedene Tabellen sind. Lua ruft __eq nur auf, wenn beide Seiten Tabellen sind; ein Sack, der mit einer Zahl verglichen wird, ist einfach nicht gleich.
• __lt ist < (less than, kleiner als). a > b ist dasselbe wie b < a, also benutzt auch > __lt. <= und >= brauchen eine eigene Metamethode, __le; ohne sie enden sie mit attempt to compare two table values.
• table.sort vergleicht Einträge mit <. Mit __lt sortiert es die Säcke ohne Vergleichsfunktion, den leichtesten zuerst. Ohne __lt endet table.sort(saecke) mit attempt to compare two table values, diesmal ohne main.lua: und Zeilennummer davor, weil der Fehler in table.sort passiert. Die Zeile, die es aufgerufen hat, findest du im Traceback unter der Meldung.

Typischer Fehler: einen Operator mit etwas zu benutzen, das kein Objekt ist. kartoffeln + 5 ruft Sack.__add(kartoffeln, 5) auf, und b.kg auf der Zahl 5 endet mit attempt to index a number value (local 'b').