Lua Academy · Ders

Aritmetik Üst Yöntemleri

Üst yöntemlerle +, -, *, / ve diğer operatörleri aşırı yükleyin.

Aritmetik Üst Yöntemleri, CoddyKit'te ücretsiz bir Lua Academy dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Lua Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Lua Academy kursu toplamda 4 dersten oluşur.

Metamethod Adları

Lua, tüm aritmetik işleçler için metamethod'lar tanımlar. Lua bir tablo üzerinde aritmetik işlem gördüğünde, ilgili metamethod'u tablonun metatable'ında arar. Her iki işlenen de tabloysa Lua önce sol işlenenin metatable'ını denetler.

-- Operator -> Metamethod
-- a + b    -> __add
-- a - b    -> __sub
-- a * b    -> __mul
-- a / b    -> __div
-- a % b    -> __mod
-- a ^ b    -> __pow
-- a // b   -> __idiv
-- -a       -> __unm (unary minus)
-- #a       -> __len
print("Metamethods defined for all Lua operators")

Vektör Toplama için __add

+ işlemini desteklemek için bir vektör tablosunda __add tanımlayın. Metamethod iki işlenen alır ve yeni bir değer döndürür. Her iki işlenen de tablo olabilir veya biri sayı olabilir; metamethod'unuz her iki durumu da ele almalıdır.

local Vec = {}
Vec.__index = Vec

Vec.__add = function(a, b)
  return setmetatable({x=a.x+b.x, y=a.y+b.y}, Vec)
end

Vec.__tostring = function(v)
  return string.format("Vec(%g,%g)", v.x, v.y)
end

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

local v1 = Vec.new(1,2)
local v2 = Vec.new(3,4)
print(tostring(v1 + v2))   -- Vec(4,6)

sub mul __div

__sub, __mul ve __div alanlarını da benzer şekilde tanımlayın. Çarpma için, metamethod'un içinde işlenen türlerini denetleyerek hem tablo*tablo hem de tablo*sayı durumlarını ele alın.

local Vec = {}
Vec.__index = Vec
local function V(x,y) return setmetatable({x=x,y=y},Vec) end
Vec.__sub = function(a,b) return V(a.x-b.x, a.y-b.y) end
Vec.__mul = function(a,b)
  if type(a)=="number" then return V(a*b.x, a*b.y)
  elseif type(b)=="number" then return V(a.x*b, a.y*b)
  else return a.x*b.x + a.y*b.y  -- dot product
  end
end
Vec.__tostring=function(v) return "("..v.x..","..v.y..")" end

local v = V(3,4)
print(tostring(v * 2))    -- (6,8)
print(tostring(V(1,0) - V(0,1)))  -- (1,-1)

__unm Tekli Eksi

__unm, Lua -obj ifadesini değerlendirdiğinde çağrılan tekli eksi metamethod'udur. İşleneni alır (tutarlılık amacıyla aynı değer iki kez geçirilir) ve değerin negatifini döndürür.

local Vec = {}
Vec.__index = Vec
local function V(x,y) return setmetatable({x=x,y=y},Vec) end
Vec.__unm = function(a) return V(-a.x, -a.y) end
Vec.__tostring = function(v)
  return string.format("(%g,%g)", v.x, v.y)
end

local v = V(3, -4)
print(tostring(-v))    -- (-3,4)
print(tostring(-(-v))) -- (3,-4)

Özel Uzunluk için __len

Bir tablo üzerinde ham tamsayı dizisi bulunmadığında #obj değerlendirildiğinde __len çağrılır. Küme, kuyruk veya ağırlıklı kapsayıcı gibi özel türler için anlamlı bir "uzunluk" döndürecek şekilde tanımlayın.

local Bag = {}
Bag.__index = Bag
Bag.__len = function(b) return b._count end

function Bag.new()
  return setmetatable({_count=0, _items={}}, Bag)
end
function Bag:add(item, qty)
  self._items[item] = (self._items[item] or 0) + (qty or 1)
  self._count = self._count + (qty or 1)
end

local bag = Bag.new()
bag:add("apple", 3)
bag:add("banana", 2)
print(#bag)   -- 5

mod ve pow

__mod, % işleçini; __pow ise ^ işleçini işler. Bunlar daha az yaygındır ancak büyük tamsayılar, kesirler veya modüler aritmetik nesneleri gibi özel sayısal türler için kullanışlıdır.

local Modular = {}
Modular.__index = Modular
local M = 1000000007

local function mod(n)
  return setmetatable({n = n % M}, Modular)
end

Modular.__add = function(a,b) return mod(a.n + b.n) end
Modular.__mul = function(a,b) return mod(a.n * b.n) end
Modular.__pow = function(a,b)
  local r, base, exp = mod(1), a, b
  while exp > 0 do
    if exp%2==1 then r = r*base end
    base = base*base; exp = math.floor(exp/2)
  end
  return r
end

print((mod(2) ^ 30).n)   -- 73741817 (2^30 mod 1e9+7)

__concat

__concat, en az bir işlenende bu metamethod bulunduğunda .. işleci tarafından tetiklenir. Bu, özel türler için birleştirme tanımlamanıza veya akıcı DSL'ler oluşturmanıza olanak tanır.

local Builder = {}
Builder.__index = Builder
Builder.__concat = function(a, b)
  local result = {}
  for _, v in ipairs(a._parts) do result[#result+1] = v end
  if type(b) == "string" then result[#result+1] = b
  else for _, v in ipairs(b._parts) do result[#result+1] = v end end
  return setmetatable({_parts=result}, Builder)
end
Builder.build = function(b) return table.concat(b._parts) end

local function S(s) return setmetatable({_parts={s}},Builder) end
print((S("Hello") .. ", " .. S("World") .. "!"):build())

Karşılaştırma Metamethod'ları

__eq, tablolar için == işleçini tanımlar (yalnızca her iki işlenen de aynı metatable'a sahip olduğunda çağrılır). __lt, < işleçini; __le ise <= işleçini tanımlar. Not: ~=, __eq kullanır; >, işlenenlerin sırası ters çevrilmiş olarak __lt kullanır; >= ise __le kullanır.

local Vec = {}
Vec.__index = Vec
local function V(x,y) return setmetatable({x=x,y=y},Vec) end

Vec.__eq = function(a,b) return a.x==b.x and a.y==b.y end
Vec.__lt = function(a,b)
  return (a.x^2+a.y^2) < (b.x^2+b.y^2)  -- by magnitude
end

print(V(1,2) == V(1,2))  -- true
print(V(1,2) == V(1,3))  -- false
print(V(1,0) < V(2,0))   -- true (1 < 2)

Metamethod'ları Zincirleme

Metamethod'lar değerler (genellikle yeni tablolar) döndürdüğünden işlemler doğal biçimde zincirlenebilir. Her işleç yeni bir nesne döndürür ve sonraki işleç bu sonucu kullanır. Bu, özel türler üzerinde akıcı aritmetik ifadeler kullanılmasını sağlar.

local Vec = {}
Vec.__index = Vec
local function V(x,y) return setmetatable({x=x,y=y},Vec) end
Vec.__add = function(a,b) return V(a.x+b.x,a.y+b.y) end
Vec.__mul = function(a,b)
  if type(b)=="number" then return V(a.x*b,a.y*b) end
  return V(a.x*b.x+a.y*b.y, 0)   -- simplified
end
Vec.__tostring=function(v) return "("..v.x..","..v.y..")" end

local result = V(1,0) + V(0,1) * 3
print(tostring(result))   -- (1,3)

Karma Türlü İşlemler

vec * 2 yazdığınızda sol işlenen tablodur. 2 * vec yazdığınızda sol işlenen sayıdır (metamethod yoktur); bu nedenle Lua, __mul için sağ işlenenin metatable'ını denetler. Metamethod'unuzda her iki işlenen sırasını da ele alın.

local Vec = {}
Vec.__index = Vec
local function V(x,y) return setmetatable({x=x,y=y},Vec) end
Vec.__tostring = function(v) return "("..v.x..","..v.y..")" end

Vec.__mul = function(a, b)
  if type(a) == "number" then
    return V(a*b.x, a*b.y)   -- scalar * vec
  elseif type(b) == "number" then
    return V(a.x*b, a.y*b)   -- vec * scalar
  end
  return a.x*b.x + a.y*b.y  -- dot product
end

print(tostring(V(1,2) * 3))  -- (3,6)
print(tostring(3 * V(1,2)))  -- (3,6)

Hızlı Denetim

-myTable tarafından hangi metamethod tetiklenir?

Özet: Aritmetik Metamethod'lar

Özet:

__add __sub __mul __div __mod __pow __idiv — ikili aritmetik
__unm — tekli eksi; __len — # işleci
__concat — .. işleci
__eq __lt __le — karşılaştırma işleçleri
Metamethod'ların içinde karma türleri (sayı/tablo) ele alın

Sıkça Sorulan Sorular

“Aritmetik Üst Yöntemleri” dersi ücretsiz mi?

Evet — “Aritmetik Üst Yöntemleri” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Lua Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Lua Academy kursu toplamda 4 dersten oluşur.

“Aritmetik Üst Yöntemleri” dersinde ne öğreneceğim?

Üst yöntemlerle +, -, *, / ve diğer operatörleri aşırı yükleyin. Lua Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Lua Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Lua Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

“Aritmetik Üst Yöntemleri” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Lua Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Lua Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Lua Academy Sayfasına Dön