Lua Academy · Pelajaran

Vararg dan Operator ...

Tangani daftar argumen dengan panjang bervariasi menggunakan ... dan select().

Vararg dan Operator ... adalah pelajaran Lua Academy gratis di CoddyKit. Ini adalah pelajaran 3 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.

Argumen Variabel

Fungsi Lua dapat menerima jumlah argumen yang bervariasi menggunakan ... (tiga titik) dalam daftar parameter. Di dalam fungsi, ... mewakili argumen tambahan. Anda dapat menggunakannya dalam ekspresi, meneruskannya ke fungsi lain, atau mengubahnya menjadi tabel.

local function sum(...)
  local total = 0
  for _, v in ipairs({...}) do
    total = total + v
  end
  return total
end

print(sum(1, 2, 3))        -- 6
print(sum(10, 20, 30, 40)) -- 100

select() untuk Argumen Variabel

select(n, ...) mengembalikan argumen mulai dari posisi n dan seterusnya. select("#", ...) mengembalikan jumlah total argumen, termasuk nilai nil. Ini lebih aman daripada #{...} yang berhenti pada celah nil pertama.

local function inspect(...)
  local n = select("#", ...)
  print("count:", n)
  for i = 1, n do
    print(i, select(i, ...))
  end
end

inspect("a", "b", nil, "d")
-- count: 4
-- 1  a
-- 2  b
-- 3  nil
-- 4  d

Meneruskan ... ke Fungsi Lain

Anda dapat meneruskan argumen variabel secara langsung ke fungsi lain dengan f(...). Ketika ... muncul sebagai argumen terakhir dalam pemanggilan, semua argumen variabel akan diteruskan. Ini berguna untuk membungkus fungsi atau melakukan pencatatan.

local function log(level, ...)
  io.write("[" .. level .. "] ")
  print(...)
end

log("INFO", "Server started on port", 8080)
log("ERROR", "File not found:", "config.lua")
-- [INFO] Server started on port  8080
-- [ERROR] File not found:  config.lua

table.pack dan table.unpack

Ubah argumen variabel menjadi tabel dengan table.pack(...), yang juga menyimpan jumlahnya dalam field n. Ubah tabel kembali menjadi argumen variabel dengan table.unpack(t, i, j). Bersama-sama, fungsi-fungsi ini memberi Anda kendali penuh atas daftar argumen variabel.

local function pack_and_show(...)
  local packed = table.pack(...)
  print("n =", packed.n)
  for i = 1, packed.n do
    print(i, packed[i])
  end
end

pack_and_show(10, nil, 30)
-- n = 3
-- 1  10
-- 2  nil
-- 3  30

Argumen Tetap dan Variabel

Sebuah fungsi dapat memiliki parameter tetap dan variabel sekaligus. Parameter tetap diletakkan lebih dahulu; ... menangkap sisanya. Parameter tetap ditetapkan sebelum sisanya dimasukkan ke dalam ....

local function printf(fmt, ...)
  io.write(string.format(fmt, ...))
end

printf("Hello, %s! You are %d years old.\n", "Alice", 30)
printf("Pi is approximately %.4f\n", math.pi)

local function firstAndRest(first, ...)
  print("first:", first)
  print("rest count:", select("#", ...))
end
firstAndRest(1, 2, 3, 4)

Argumen Variabel dalam Konstruktor Tabel

Anda dapat langsung membentangkan argumen variabel ke dalam konstruktor tabel: {...}. Jika digunakan sebagai elemen terakhir, semua argumen akan disertakan. Namun, celah nil dapat membingungkan # — gunakan table.pack jika Anda memerlukan jumlah yang tepat.

local function toArray(...)
  return {...}  -- collect all args as array
end

local arr = toArray("x", "y", "z")
for i, v in ipairs(arr) do
  print(i, v)
end
-- 1  x
-- 2  y
-- 3  z

Ekspresi Argumen Variabel

... dapat muncul di posisi ekspresi mana pun. Dalam penugasan majemuk, argumen tersebut meluas menjadi semua nilainya. Dalam ekspresi aritmetika, hanya nilai pertama yang digunakan. Memahami perilaku ini membantu mencegah galat tersembunyi saat mencampur ... dengan ekspresi lain.

local function first(...)
  local x = ...
  return x
end

print(first(10, 20, 30))  -- 10  (only first)

local function addFirst(n, ...)
  local x = ...
  return n + x
end
print(addFirst(5, 3, 99)) -- 8  (3 is first ...)

print() Menggunakan Argumen Variabel

print() bawaan Lua sendiri merupakan fungsi dengan jumlah argumen variabel. Fungsi ini menerima sejumlah argumen, mengubah masing-masing menjadi string, lalu memisahkannya dengan tab. Memahami hal ini membantu Anda menulis fungsi utilitas serupa.

-- print is vararg
print(1, 2, 3)           -- 1  2  3
print("a", nil, "b")     -- a  nil  b
print()                  -- (empty line)

-- Reimplementing a simple print-like function
local function myprint(...)
  local parts = {}
  for i = 1, select("#", ...) do
    parts[i] = tostring(select(i, ...))
  end
  io.write(table.concat(parts, "\t") .. "\n")
end
myprint(10, nil, 30)

Meneruskan dengan pcall

Gabungkan pcall dengan argumen variabel untuk membuat pembungkus pemanggilan aman yang bersifat umum. Pembungkus ini menerima sebuah fungsi dan argumen apa pun, memanggilnya melalui pcall, lalu mengembalikan hasil atau galat.

local function safeCall(fn, ...)
  local ok, result = pcall(fn, ...)
  if ok then
    return result
  else
    print("Error:", result)
    return nil
  end
end

local function divide(a, b)
  assert(b ~= 0, "division by zero")
  return a / b
end

print(safeCall(divide, 10, 2))   -- 5.0
print(safeCall(divide, 10, 0))  -- Error: ...

Pola Mengakumulasi Argumen Variabel

Pola argumen variabel yang umum adalah mengiterasi semua argumen dan mengakumulasikan hasil. Hal ini dapat dilakukan dengan tabel lokal atau dengan langsung menjumlahkannya menggunakan select. Keduanya valid; pendekatan tabel lebih rapi untuk banyak argumen.

local function average(...)
  local n = select("#", ...)
  if n == 0 then return 0 end
  local total = 0
  for i = 1, n do
    total = total + select(i, ...)
  end
  return total / n
end

print(average(10, 20, 30, 40))  -- 25.0
print(average(5))               -- 5.0

Pemeriksaan Cepat

Apa yang dikembalikan oleh select("#", 1, nil, 3)?

Ringkasan: Argumen Variabel

Ringkasan:

function f(...) — menerima argumen variabel
select("#", ...) — menghitung dengan aman, termasuk nilai nil
select(n, ...) — nilai mulai dari posisi n
table.pack(...) — argumen variabel menjadi tabel dengan jumlah .n
table.unpack(t) — tabel menjadi argumen variabel
... pada posisi terakhir meluas sepenuhnya; pada posisi tengah menghasilkan satu nilai

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Vararg dan Operator ...” gratis?

Ya — teks lengkap “Vararg dan Operator ...” 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 “Vararg dan Operator ...”?

Tangani daftar argumen dengan panjang bervariasi menggunakan ... dan select(). 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 3 dari 4.

Berapa lama pelajaran “Vararg dan Operator ...” 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