Lua Academy · Oppitunti

tostring ja len

Ohjatkaa merkkijonoesitystä ja #-operaattoria metametodeilla.

Oppitunti 4/412 vaihetta

__tostring ja __len on ilmainen Lua Academy-oppitunti CoddyKitissä. Tämä on oppitunti 4/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Lua Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Lua Academy-kurssilla on yhteensä 4 oppituntia.

__tostring-metametodi

__tostring-metametodia kutsutaan, kun tostring(obj) suoritetaan, sekä print()-funktion toimesta, joka kutsuu tostring-funktiota jokaiselle argumentille. Määrittäkää se antamaan mukautetuille olioille ihmiselle luettava esitysmuoto.

local Point = {}
Point.__index = Point
Point.__tostring = function(p)
  return string.format("Point(%.2f, %.2f)", p.x, p.y)
end

function Point.new(x,y)
  return setmetatable({x=x,y=y}, Point)
end

local p = Point.new(3.14, 2.72)
print(p)            -- Point(3.14, 2.72)
print(tostring(p))  -- Point(3.14, 2.72)

__len jonoille

__len-metametodia kutsutaan, kun #-operaattoria käytetään taulukolle, jolla on tämä metametodi. Lua 5.2:ssa ja uudemmissa __len-metametodia kutsutaan aina taulukoille; versiossa 5.1 sitä kutsutaan vain userdata-arvoille. Käyttäkää sitä mukautettujen säiliöiden "pituuden" määrittämiseen.

local Queue = {}
Queue.__index = Queue
Queue.__len = function(q) return q._tail - q._head + 1 end

function Queue.new()
  return setmetatable({_data={},_head=1,_tail=0}, Queue)
end
function Queue:push(v)
  self._tail = self._tail + 1
  self._data[self._tail] = v
end
function Queue:pop()
  if self._head > self._tail then return nil end
  local v = self._data[self._head]
  self._head = self._head + 1
  return v
end

local q = Queue.new()
q:push("a"); q:push("b"); q:push("c")
print(#q)   -- 3

Monipuolinen __tostring virheenkorjaukseen

Hyvä __tostring-metametodi sisältää tyypin nimen ja tärkeimmät kentät. Sisäkkäisten olioiden kohdalla kutsukaa tostring-funktiota rekursiivisesti. Tämä helpottaa virheenkorjausta huomattavasti oletustulostetta "table: 0x..." enemmän.

local function tableToString(t, depth)
  depth = depth or 0
  if depth > 3 then return "{...}" end
  local parts = {}
  for k, v in pairs(t) do
    if type(v) == "table" then
      parts[#parts+1] = k.."="..tableToString(v, depth+1)
    else
      parts[#parts+1] = k.."="..tostring(v)
    end
  end
  return "{"..table.concat(parts,", ").."}"
end

local obj = {name="test", data={x=1,y=2}, active=true}
print(tableToString(obj))

__len ja #-operaattori

Taulukoille, joilla ei ole __len-metametodia, #t etsii minkä tahansa jonon rajan (kohdan, jossa t[i] ~= nil ja t[i+1] == nil). Jos taulukossa on aukkoja, tulos on ennalta arvaamaton. __len mahdollistaa yksiselitteisen ja johdonmukaisen pituuden määrittämisen.

-- Table with hole: # is unpredictable
local t = {10, 20, nil, 40}
print(#t)  -- could be 2 or 4, undefined!

-- Custom container with authoritative length
local SafeList = {}
SafeList.__index = SafeList
SafeList.__len = function(s) return s._size end

function SafeList.new()
  return setmetatable({_data={}, _size=0}, SafeList)
end
function SafeList:add(v)
  self._size = self._size + 1
  self._data[self._size] = v
end
local s = SafeList.new()
s:add(1); s:add(nil); s:add(3)
print(#s)   -- 3 (always correct)

__tostring virheilmoituksissa

Kun käytätte virheolioita (merkkijonojen sijaan taulukoita), määritetty __tostring-metametodi tekee virheilmoituksista luettavia, kun virhe välittyy eteenpäin ja muunnetaan merkkijonoksi.

local function makeError(code, msg)
  return setmetatable(
    {code=code, message=msg},
    {__tostring = function(e)
      return string.format("Error[%d]: %s", e.code, e.message)
    end}
  )
end

local ok, err = pcall(function()
  error(makeError(404, "resource not found"))
end)

if not ok then
  -- err is the error object (table)
  print(tostring(err))  -- may show table address...

__tostring perinnässä

Kun käytätte prototyyppipohjaista olio-ohjelmointia, määrittäkää __tostring luokan metataulussa. Kaikki instanssit käyttävät automaattisesti luokan __tostring-metametodia, koska instanssin metataulu ON luokkataulukko.

local Animal = {}
Animal.__index = Animal
Animal.__tostring = function(a)
  return string.format("%s(%s)", a._type or "Animal", a.name or "?")
end

function Animal.new(name, atype)
  return setmetatable({name=name, _type=atype}, Animal)
end

local cat = Animal.new("Whiskers", "Cat")
local dog = Animal.new("Rex", "Dog")
print(cat)  -- Cat(Whiskers)
print(dog)  -- Dog(Rex)

Set-tietotyypin toteuttaminen len- ja tostring-metodeilla

Yhdistäkää __len ja __tostring yhteen tyyppiin täydellisen ja käyttäjäystävällisen Set-toteutuksen luomiseksi.

local Set = {}
Set.__index = Set
Set.__len = function(s) return s._size end
Set.__tostring = function(s)
  local items = {}
  for k in pairs(s._data) do items[#items+1]=tostring(k) end
  table.sort(items)
  return "Set{" .. table.concat(items,", ") .. "}"
end

function Set.new(...)
  local obj = setmetatable({_data={},_size=0}, Set)
  for _, v in ipairs({...}) do
    if not obj._data[v] then obj._data[v]=true; obj._size=obj._size+1 end
  end
  return obj
end

local s = Set.new(3,1,4,1,5,9,2,6)
print(#s)         -- 7 (duplicates removed)
print(tostring(s)) -- Set{1, 2, 3, 4, 5, 6, 9}

Numeeriset oliot molemmilla

Luokaa murtolukutyyppi, jossa __tostring huolehtii näyttämisestä ja __len ilmaisee numeroiden määrän (tai toimialakohtaisen suureen).

local Frac = {}
Frac.__index = Frac

local function gcd(a,b) return b==0 and a or gcd(b,a%b) end

function Frac.new(n,d)
  local g = gcd(math.abs(n), math.abs(d))
  return setmetatable({n=n//g, d=d//g}, Frac)
end

Frac.__tostring = function(f)
  if f.d==1 then return tostring(f.n) end
  return f.n .. "/" .. f.d
end

Frac.__add = function(a,b)
  return Frac.new(a.n*b.d + b.n*a.d, a.d*b.d)
end

local a = Frac.new(1,2)
local b = Frac.new(1,3)
print(a + b)   -- 5/6

Oletusarvoisen print-toiminnan korvaaminen

Luan print kutsuu tostring-funktiota jokaiselle argumentille ja erottaa tulokset sarkaimilla. Kun __tostring on määritetty, olionne näkyvät merkityksellisessä muodossa kaikissa print-lauseissa, virheilmoituksissa tai merkkijonojen interpoloinneissa, joissa käytetään tostring-funktiota.

local Color = {}
Color.__index = Color
Color.__tostring = function(c)
  return string.format("#%02X%02X%02X", c.r, c.g, c.b)
end

function Color.new(r,g,b)
  return setmetatable({r=r,g=g,b=b}, Color)
end

local red   = Color.new(255,0,0)
local green = Color.new(0,255,0)
local blue  = Color.new(0,0,255)

print(red, green, blue)
-- #FF0000  #00FF00  #0000FF

__name Lua 5.3+:ssa

Lua 5.3 ja uudemmat tukevat metataulussa __name-kenttää, jota oletusarvoiset virheilmoitukset käyttävät tyypin tunnistamiseen. Se ei vaikuta suoraan tostring()-funktion toimintaan, mutta näkyy ajonaikaisissa virheilmoituksissa, kun tyypille tehdään virheellisiä operaatioita.

local MyType = {}
MyType.__index = MyType
MyType.__name = "MyType"   -- used in error messages
MyType.__tostring = function(t)
  return "MyType(" .. tostring(t.value) .. ")"
end

local obj = setmetatable({value=42}, MyType)
print(obj)             -- MyType(42)

-- Error message will say "MyType" instead of "table"
-- pcall(function() local x = obj + 1 end)

Pikatarkistus

Milloin __tostring-metametodia kutsutaan?

Vastaa interaktiivisessa oppitunnissa

Kertaus: tostring ja len

Yhteenveto:

__tostring: tostring()- ja print()-funktiot kutsuvat sitä
__len: kutsutaan lausekkeella #obj; tarjoaa mukautetuille säiliöille yksiselitteisen pituuden
Määrittäkää __tostring luokkataulukoille, jotta kaikki instanssit käyttävät sitä
Käyttäkää __len-metametodia, kun raaka taulukkorakenne ei anna oikeaa #-tulosta
__name (5.3+) nimeää tyypin virheilmoituksissa

Aloita maksutta

Opi Lua tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 40
Oppitunnit: 159

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”tostring ja len” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Lua Academy-oppimispolun 3 oppituntia, myös oppitunnin “__tostring ja __len”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Lua Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”tostring ja len”?

Ohjatkaa merkkijonoesitystä ja #-operaattoria metametodeilla. Harjoittelet Lua Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Lua Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Lua Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 4/4.

Kuinka kauan ”tostring ja len”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Lua Academy-oppitunnilla?

Kyllä. Jokainen Lua Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

← Takaisin: Lua Academy