Lua Academy · Ders

resume ve yield

resume/yield ile çağıran ve coroutine arasında veri alışverişi yapın.

resume ve yield, CoddyKit'te ücretsiz bir Lua Academy dersidir. Bu, 4 dersinin 2. 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.

Coroutine'e Değer Aktarma

İlk coroutine.resume çağrısına aktarılan bağımsız değişkenler, coroutine gövdesindeki işlevin parametreleri olur. Sonraki resume çağrılarına aktarılan bağımsız değişkenler, coroutine'i duraklatan coroutine.yield() çağrısı tarafından döndürülür.

local co = coroutine.create(function(a, b)
  print("received:", a, b)        -- 10  20
  local c = coroutine.yield()     -- pauses
  print("after yield:", c)        -- 30
end)

coroutine.resume(co, 10, 20)  -- first call: passes a,b
coroutine.resume(co, 30)      -- subsequent: passed to yield

yield'den Gelen Değerler

coroutine.yield(val1, val2) çağrısına aktarılan değerler, yield noktasında duran coroutine.resume() çağrısının dönüş değerleri olur. Yani yield, çağırana değerler "döndürür".

local co = coroutine.create(function()
  coroutine.yield(1, "hello")
  coroutine.yield(2, "world")
  return 3, "done"
end)

local ok, a, b = coroutine.resume(co)
print(ok, a, b)   -- true  1  hello

ok, a, b = coroutine.resume(co)
print(ok, a, b)   -- true  2  world

ok, a, b = coroutine.resume(co)
print(ok, a, b)   -- true  3  done

Çift Yönlü İletişim

Coroutine'ler gerçek çift yönlü iletişim sağlar: çağıran, resume aracılığıyla veri aktarır; coroutine bu veriyi işler ve sonuçları yield ile geri gönderir. Her resume/yield işlemi eşzamanlı bir alışveriştir.

local co = coroutine.create(function(x)
  while true do
    x = coroutine.yield(x * x)  -- yield x^2, get next x
  end
end)

coroutine.resume(co)  -- start (x=nil initially)
local ok, sq
ok, sq = coroutine.resume(co, 3); print(sq)  -- 9
ok, sq = coroutine.resume(co, 5); print(sq)  -- 25
ok, sq = coroutine.resume(co, 7); print(sq)  -- 49

Üretici-Tüketici

Klasik coroutine kalıbı: üretici öğeleri birer birer yield eder; tüketici bir sonraki öğeye ihtiyaç duyduğunda üreticiyi resume eder. Hiçbiri diğerinin önüne geçmez; bu, kusursuz bir eşzamanlamadır.

local function producer(items)
  return coroutine.create(function()
    for _, item in ipairs(items) do
      coroutine.yield(item)
    end
  end)
end

local pro = producer({"apple","banana","cherry"})

-- Consumer drives the loop
while true do
  local ok, item = coroutine.resume(pro)
  if not ok or item == nil then break end
  print("consumed:", item)
end

Coroutine'lerle İşlem Hattı

Birden çok coroutine'i işlem hattı olarak zincirleyin. Her aşama önceki aşamadan okur ve sonraki aşamaya yield eder. Son aşamayı resume ederek işlem hattını son aşama sürükler; bu işlem zincir boyunca geriye doğru yayılır.

local function source(items)
  return coroutine.wrap(function()
    for _, v in ipairs(items) do coroutine.yield(v) end
  end)
end

local function filter(iter, pred)
  return coroutine.wrap(function()
    for v in iter do
      if pred(v) then coroutine.yield(v) end
    end
  end)
end

local function map(iter, fn)
  return coroutine.wrap(function()
    for v in iter do coroutine.yield(fn(v)) end
  end)
end

local pipeline = map(filter(source({1,2,3,4,5,6}),
  function(n) return n%2==0 end),
  function(n) return n*n end)

for v in pipeline do io.write(v.." ") end
print()  -- 4 16 36

Eşzamansız Benzetim için Coroutine'ler

OS iş parçacıkları olmadan coroutine'ler eşzamansız işlemleri taklit edebilir: "beklerken" yield edin ve "sonuç" hazır olduğunda resume edin. Bir zamanlayıcı, coroutine'i sonuçla birlikte resume eder.

local scheduler = {}
local current = nil

local function await(key)
  coroutine.yield(key)  -- tell scheduler what we need
  return coroutine.yield()  -- wait for result
end

local co = coroutine.create(function()
  local data = await("fetch:users")
  print("Got users:", data)
end)

-- Start coroutine
local ok, want = coroutine.resume(co)
print("Coroutine wants:", want)  -- fetch:users
-- Simulate delivering the result:
coroutine.resume(co, {{name="Alice"},{name="Bob"}})

Bir İşlevin İçinde yield

Yalnızca en üst düzey işlevden değil, coroutine tarafından çağrılan herhangi bir işlevin içinden de yield edebilirsiniz. yield, tüm iç içe çağrılar boyunca yukarı ilerleyerek resume çağrısına geri döner. Buna "askıya alınmış çağrı yığını" denir.

local function yieldTwice(label)
  coroutine.yield(label .. ":1")
  coroutine.yield(label .. ":2")
end

local co = coroutine.create(function()
  yieldTwice("A")
  yieldTwice("B")
end)

for i = 1, 4 do
  local ok, v = coroutine.resume(co)
  print(v)
end
-- A:1, A:2, B:1, B:2

Coroutine'ler İş Parçacığı Değildir

Lua coroutine'leri OS iş parçacıkları değildir. Aynı anda yalnızca bir coroutine çalışır; öncelikli kesme veya paralellik yoktur. Tüm coroutine'ler tek bir OS iş parçacığını paylaşır. Gerçek paralellik için ayrı OS iş parçacıklarında birden çok Lua durumu gerekir.

-- This is NOT parallel - interleaved execution
local function task(name, n)
  for i = 1, n do
    print(name, i)
    coroutine.yield()
  end
end

local t1 = coroutine.create(function() task("A", 3) end)
local t2 = coroutine.create(function() task("B", 3) end)

-- Must explicitly schedule:
for _ = 1, 3 do
  coroutine.resume(t1)
  coroutine.resume(t2)
end
-- A1, B1, A2, B2, A3, B3 (interleaved, NOT parallel)

Resume Sonrası Durum

Yeniden resume edip etmeyeceğinize karar vermek için coroutine durumunu kontrol edin. Tamamlanmış, yani gövdesinden dönmüş bir coroutine "ölü" durumdadır; onu resume etmek false ve bir hata döndürür. Döngülerde resume etmeden önce her zaman durumu kontrol edin.

local co = coroutine.create(function()
  for i = 1, 3 do coroutine.yield(i) end
end)

while coroutine.status(co) ~= "dead" do
  local ok, val = coroutine.resume(co)
  if ok and val ~= nil then
    print("val:", val)
  end
end
-- val: 1, val: 2, val: 3

Tek Bir Resume'de Birden Çok yield

coroutine.resume çağrısı, coroutine'i bir sonraki yield noktasına veya sona ulaşana kadar çalıştırır. Bir coroutine'in tek bir resume içinde birden çok kez yield etmesini sağlayamazsınız; her yield işlemi coroutine'i askıya alır ve bir sonraki resume'i bekler.

local co = coroutine.create(function()
  local x = coroutine.yield("first")
  print("got:", x)
  local y = coroutine.yield("second")
  print("got:", y)
end)

local _, v1 = coroutine.resume(co)         -- starts, yields "first"
print("yielded:", v1)                       -- first
local _, v2 = coroutine.resume(co, "a")   -- passes "a", yields "second"
print("yielded:", v2)                       -- second
coroutine.resume(co, "b")                   -- passes "b", coroutine ends

Hızlı Kontrol

coroutine.yield(v1, v2) çağrısına aktarılan değerler neye dönüşür?

Özet: resume ve yield

Özet:

İlk resume bağımsız değişkenleri → coroutine gövdesi parametreleri
Sonraki resume bağımsız değişkenleri → önceki yield() tarafından döndürülen değerler
yield bağımsız değişkenleri → yield işlemini tetikleyen resume() çağrısı tarafından döndürülen değerler
Çift yönlü: her resume/yield bir alışveriştir
Her iç içe işlevden yield etmek mümkündür
Coroutine'ler işbirliklidir, paralel değildir

Sıkça Sorulan Sorular

“resume ve yield” dersi ücretsiz mi?

Evet — “resume ve yield” 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.

“resume ve yield” dersinde ne öğreneceğim?

resume/yield ile çağıran ve coroutine arasında veri alışverişi yapın. 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 2. dersidir.

“resume ve yield” 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