Lua Academy · Pelajaran

resume dan yield

Tukarkan data antara pemanggil dan coroutine dengan resume/yield.

resume dan yield adalah pelajaran Lua Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Lua Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Lua Academy mencakup 4 pelajaran total.

Meneruskan Nilai ke Korutin

Argumen yang diteruskan ke coroutine.resume pertama menjadi parameter fungsi pada badan korutin. Argumen yang diteruskan ke resume berikutnya dikembalikan oleh pemanggilan coroutine.yield() yang menghentikan sementara korutin.

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

Nilai dari yield

Nilai yang diteruskan ke coroutine.yield(val1, val2) menjadi nilai kembalian dari pemanggilan coroutine.resume() yang berhenti sementara pada yield tersebut. Jadi, yield "mengembalikan" nilai kepada pemanggil.

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

Komunikasi Dua Arah

Korutin memungkinkan komunikasi dua arah yang sesungguhnya: pemanggil mengirimkan data melalui resume, korutin memprosesnya, lalu mengirimkan hasil kembali melalui yield. Setiap resume/yield merupakan pertukaran sinkron.

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

Produsen-Konsumen

Pola korutin klasik: produsen melakukan yield pada item satu per satu; konsumen melanjutkan produsen setiap kali membutuhkan item berikutnya. Keduanya tidak berjalan mendahului yang lain — sinkronisasi yang sempurna.

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

Alur dengan Korutin

Rangkai beberapa korutin sebagai sebuah alur. Setiap tahap membaca dari tahap sebelumnya dan melakukan yield ke tahap berikutnya. Tahap terakhir menggerakkan alur dengan melanjutkan tahap terakhir tersebut, yang kemudian memicu rangkaian kembali melalui semua tahap.

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

Korutin untuk Simulasi Asinkron

Tanpa thread OS, korutin dapat menyimulasikan operasi asinkron: lakukan yield saat "menunggu", lalu lanjutkan ketika "hasil" sudah siap. Penjadwal melanjutkan korutin dengan membawa hasil tersebut.

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"}})

yield di Dalam Fungsi

Anda dapat melakukan yield dari dalam fungsi apa pun yang dipanggil oleh korutin, bukan hanya dari fungsi tingkat teratas. Yield diteruskan ke atas melalui semua pemanggilan bertingkat hingga kembali ke resume. Ini disebut "stack pemanggilan yang ditangguhkan".

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

Korutin Bukan Thread

Korutin Lua bukan thread OS. Hanya satu korutin yang berjalan pada satu waktu; tidak ada preemption atau paralelisme. Semua korutin berbagi satu thread OS. Untuk paralelisme sesungguhnya, Anda memerlukan beberapa state Lua dalam thread OS yang terpisah.

-- 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)

Status Setelah Resume

Periksa status korutin untuk menentukan apakah korutin perlu dilanjutkan lagi. Korutin yang telah selesai (keluar dari badannya) berada dalam keadaan "mati" — melanjutkannya akan mengembalikan false disertai kesalahan. Selalu periksa status sebelum melanjutkan korutin di dalam perulangan.

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

Beberapa Yield dalam Satu Resume

Satu pemanggilan coroutine.resume menjalankan korutin hingga yield berikutnya atau hingga korutin berakhir. Anda tidak dapat membuat korutin melakukan yield beberapa kali dalam satu resume — setiap yield menghentikan sementara korutin dan menunggu resume berikutnya.

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

Pemeriksaan Singkat

Nilai yang diteruskan ke coroutine.yield(v1, v2) menjadi apa?

Ringkasan: resume dan yield

Ringkasan:

Argumen resume pertama → parameter badan korutin
Argumen resume berikutnya → dikembalikan oleh yield() sebelumnya
Argumen yield → dikembalikan oleh resume() yang memicu yield tersebut
Dua arah: setiap resume/yield merupakan sebuah pertukaran
yield dari fungsi bertingkat mana pun dapat digunakan
Korutin: kooperatif, bukan paralel

Pertanyaan yang Sering Diajukan

Apakah pelajaran “resume dan yield” gratis?

Ya — teks lengkap “resume dan yield” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Lua Academy, upgrade ke CoddyKit PRO. Kursus Lua Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “resume dan yield”?

Tukarkan data antara pemanggil dan coroutine dengan resume/yield. Kamu berlatih Lua Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Lua Academy?

Tidak diperlukan pengalaman sebelumnya. Lua Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “resume dan yield” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Lua Academy ini?

Ya. Setiap pelajaran Lua Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Lua Academy