Lua Academy · Lekcja

Konstruktory i new()

Proszę pisać funkcje konstruktorów, które tworzą i inicjalizują instancje.

Konstruktory i new() to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Lua Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Lua Academy zawiera 4 lekcji w sumie.

Odpowiedzialność konstruktora

Konstruktor tworzy i inicjalizuje instancję. Otrzymuje wartości początkowe, sprawdza ich poprawność, ustawia wartości domyślne dla brakujących pól i zwraca nową instancję. Dobrze zaprojektowany konstruktor zapewnia, że każda instancja rozpoczyna działanie w prawidłowym stanie.

local Player = {}
Player.__index = Player

function Player.new(name, hp, mp)
  assert(type(name)=="string" and name~="","need name")
  return setmetatable({
    name = name,
    hp   = hp or 100,
    mp   = mp or 50,
    alive = true,
    items = {},
  }, Player)
end

local p = Player.new("Hero")
print(p.name, p.hp, p.mp)  -- Hero  100  50

Konstruktor płynny

Konstruktor płynny zwraca self z metod setterów, umożliwiając łańcuchowe wywoływanie metod podczas tworzenia obiektu. Jest to wzorzec budowniczego w Lua.

local Config = {}
Config.__index = Config

function Config.new()
  return setmetatable({_data={}}, Config)
end

function Config:set(k,v) self._data[k]=v; return self end
function Config:build() return self._data end

local cfg = Config.new()
  :set("host","localhost")
  :set("port",8080)
  :set("debug",true)
  :build()

print(cfg.host, cfg.port)

Konstruktor kopiujący

Konstruktor kopiujący tworzy nową instancję z takimi samymi wartościami jak istniejąca instancja. Ważne: należy użyć płytkiej lub głębokiej kopii, zależnie od tego, czy zagnieżdżone tabele powinny być współdzielone, czy niezależne.

local function deepCopy(orig)
  if type(orig)~="table" then return orig end
  local copy = {}
  for k,v in pairs(orig) do copy[deepCopy(k)]=deepCopy(v) end
  return setmetatable(copy, getmetatable(orig))
end

local Item = {}
Item.__index = Item

function Item.new(name, stats)
  return setmetatable({name=name, stats=stats or {}}, Item)
end

function Item:clone()
  return deepCopy(self)
end

local sword = Item.new("Sword",{damage=50})
local clone = sword:clone()
clone.stats.damage = 30
print(sword.stats.damage)  -- 50 (unchanged)

Konstruktor z walidacją

Należy zawsze sprawdzać poprawność danych wejściowych konstruktora. W przypadku nieprawidłowych danych należy zgłaszać opisowe błędy na poziomie 2 (wskazujące na wywołującego). Pozwala to wcześnie wykrywać błędy i generować pomocne komunikaty.

local Rectangle = {}
Rectangle.__index = Rectangle

function Rectangle.new(w, h)
  assert(type(w)=="number" and w>0,"width must be positive number")
  assert(type(h)=="number" and h>0,"height must be positive number")
  return setmetatable({width=w, height=h}, Rectangle)
end

function Rectangle:area() return self.width * self.height end
function Rectangle:perimeter() return 2*(self.width+self.height) end

local r = Rectangle.new(5, 3)
print(r:area(), r:perimeter())  -- 15  16

Wzorzec wartości domyślnych

Należy używać tabeli wartości domyślnych, aby przejrzyście obsługiwać opcjonalne parametry konstruktora. Pozwala to uniknąć długich ciągów x = x or default oraz sprawia, że wartości domyślne są jawne i łatwe do zmiany.

local Sprite = {}
Sprite.__index = Sprite

local DEFAULTS = {x=0,y=0,rotation=0,scale=1,visible=true,alpha=1}

function Sprite.new(image, opts)
  local cfg = opts or {}
  local self = {image=image}
  for k,v in pairs(DEFAULTS) do
    self[k] = cfg[k] ~= nil and cfg[k] or v
  end
  return setmetatable(self, Sprite)
end

local s = Sprite.new("hero.png",{x=100,y=200})
print(s.x,s.y,s.scale)  -- 100 200 1

Statyczne metody fabrykujące

Klasa może mieć wiele metod fabrykujących dla różnych scenariuszy tworzenia obiektów. Jest to czytelniejsze niż przeciążanie jednego konstruktora wieloma opcjonalnymi parametrami.

local Color = {}
Color.__index = Color

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

function Color.fromHex(hex)
  hex = hex:gsub("#","")
  return setmetatable({
    r=tonumber(hex:sub(1,2),16),
    g=tonumber(hex:sub(3,4),16),
    b=tonumber(hex:sub(5,6),16),
  }, Color)
end

function Color:toHex()
  return string.format("#%02X%02X%02X",self.r,self.g,self.b)
end

local red = Color.fromHex("#FF0000")
print(red:toHex())  -- #FF0000

Rejestr konstruktorów

Należy użyć rejestru do śledzenia wszystkich instancji. Umożliwia to wykonywanie globalnych operacji, takich jak „zniszcz wszystkie”, oraz iterowanie po wszystkich obiektach danego typu.

local Enemy = {}
Enemy.__index = Enemy
Enemy._all = {}

function Enemy.new(name, hp)
  local self = setmetatable({name=name, hp=hp}, Enemy)
  Enemy._all[#Enemy._all+1] = self
  return self
end

function Enemy.destroyAll()
  for _, e in ipairs(Enemy._all) do
    print("Destroying:", e.name)
  end
  Enemy._all = {}
end

Enemy.new("Goblin",30)
Enemy.new("Orc",80)
print("Count:", #Enemy._all)  -- 2
Enemy.destroyAll()

Leniwa inicjalizacja

Obliczenie niektórych pól może być kosztowne. Należy użyć __index z funkcją, aby obliczać te pola i buforować je przy pierwszym dostępie.

local BigData = {}
BigData.__index = function(t, k)
  if k == "processed" then
    print("Computing processed...")
    local result = {}
    for i,v in ipairs(rawget(t,"raw")) do result[i]=v*2 end
    rawset(t,"processed",result)
    return result
  end
end

function BigData.new(raw)
  return setmetatable({raw=raw}, BigData)
end

local d = BigData.new({1,2,3,4,5})
print(d.processed[3])  -- Computing...  6
print(d.processed[3])  -- 6 (cached, no recompute)

Prototyp z instancji

Należy sklonować instancję, aby utworzyć inną z takimi samymi wartościami bazowymi. Klon otrzymuje tę samą metatabelę (czyli tę samą klasę) oraz kopię danych instancji. Jest to przydatne w przypadku obiektów „szablonowych”.

local Unit = {}
Unit.__index = Unit

function Unit.new(t)
  return setmetatable({name=t.name,hp=t.hp,atk=t.atk}, Unit)
end

function Unit:clone()
  return Unit.new({name=self.name,hp=self.hp,atk=self.atk})
end

function Unit:__tostring()
  return self.name.."(HP:"..self.hp..",ATK:"..self.atk..")"
end

local template = Unit.new({name="Soldier",hp=100,atk=10})
local u1 = template:clone(); u1.name="Alpha"
local u2 = template:clone(); u2.name="Beta"
print(tostring(u1),tostring(u2))

Bezpieczeństwo błędów konstruktora

Jeśli tworzenie obiektu nie powiedzie się w trakcie (np. podczas przydzielania zasobu), należy dopilnować, aby nie wydostały się niekompletne obiekty. Należy użyć pcall do przechwycenia błędów tworzenia i w razie potrzeby zwolnienia zasobów.

local FileHandle = {}
FileHandle.__index = FileHandle

function FileHandle.new(path, mode)
  local f, err = io.open(path, mode or "r")
  if not f then
    return nil, "cannot open " .. path .. ": " .. err
  end
  return setmetatable({_f=f, path=path}, FileHandle)
end

function FileHandle:read(fmt) return self._f:read(fmt) end
function FileHandle:close() self._f:close() end

local fh, err = FileHandle.new("data.txt")
if not fh then print("Error:", err)
else print(fh:read("l")); fh:close()
end

Szybkie sprawdzenie

Jaka jest rola konstruktora (new()) w obiektowym Lua?

Podsumowanie: konstruktory

Podsumowanie:

Konstruktor sprawdza poprawność danych, inicjalizuje obiekt i wywołuje setmetatable
Należy używać tabeli wartości domyślnych do przejrzystej obsługi opcjonalnych parametrów
Wiele metod fabrykujących obsługuje różne scenariusze tworzenia obiektów
Konstruktor kopiujący służy do tworzenia obiektów szablonowych
Leniwa inicjalizacja przez __index obsługuje kosztowne pola
W przypadku niepowodzenia konstruktor powinien zwracać nil+err (np. podczas przydzielania zasobu)

Często zadawane pytania

Czy lekcja „Konstruktory i new()” jest bezpłatna?

Tak — pełny tekst „Konstruktory i new()” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Lua Academy, przejdź na CoddyKit PRO. Kurs Lua Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Konstruktory i new()”?

Proszę pisać funkcje konstruktorów, które tworzą i inicjalizują instancje. Ćwiczysz Lua Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Lua Academy?

Nie wymagamy żadnego doświadczenia. Lua Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Konstruktory i new()”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Lua Academy?

Tak. Każda lekcja Lua Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Lua Academy