Lua Academy · Pelajaran

Tabel sebagai Larik

Buat dan manipulasi larik berindeks mulai dari 1 dengan table.insert dan table.remove.

Pelajaran 1 dari 412 langkah

Tabel sebagai Larik adalah pelajaran Lua Academy gratis di CoddyKit. Ini adalah pelajaran 1 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.

Larik dengan Indeks Mulai 1

Larik Lua adalah tabel dengan kunci bilangan bulat berurutan yang dimulai dari 1. Ini berbeda dari kebanyakan bahasa yang dimulai dari 0. Konvensi ini berlaku universal dalam Lua — semua fungsi pustaka standar mengasumsikan pengindeksan berbasis 1. Akses di luar batas mengembalikan nil, bukan galat.

local colors = {"red", "green", "blue"}
print(colors[1])   -- red
print(colors[2])   -- green
print(colors[3])   -- blue
print(colors[0])   -- nil (no index 0)
print(#colors)     -- 3 (length operator)

table.insert dan table.remove

table.insert(t, val) menambahkan elemen ke akhir. table.insert(t, pos, val) menyisipkan elemen pada suatu posisi dan menggeser elemen ke kanan. table.remove(t, pos) menghapus elemen pada pos (bawaan: elemen terakhir), menggeser elemen ke kiri, lalu mengembalikan nilai yang dihapus.

local stack = {}
table.insert(stack, "first")
table.insert(stack, "second")
table.insert(stack, "third")
print(#stack)          -- 3

table.insert(stack, 2, "inserted")
print(stack[2])        -- inserted

local removed = table.remove(stack, 1)
print(removed)         -- first
print(stack[1])        -- inserted

Tumpukan dengan Tabel

Tabel Lua merupakan tumpukan yang sempurna. Gunakan table.insert untuk memasukkan elemen dan table.remove untuk mengeluarkannya. Secara bawaan, kedua operasi bekerja dari akhir tabel sehingga menghasilkan waktu diamortisasi O(1).

local stack = {}

-- Push
table.insert(stack, 10)
table.insert(stack, 20)
table.insert(stack, 30)

-- Pop
print(table.remove(stack))  -- 30
print(table.remove(stack))  -- 20
print(#stack)               -- 1

Antrean dengan Tabel

Antrean (FIFO) dapat diimplementasikan dengan tabel, tetapi table.remove(t, 1) memiliki kompleksitas O(n) karena menggeser semua elemen. Untuk antrean berperforma tinggi, gunakan dua penunjuk (indeks kepala dan ekor) agar tidak perlu menggeser elemen.

local head, tail = 1, 0
local queue = {}

local function enqueue(v)
  tail = tail + 1
  queue[tail] = v
end

local function dequeue()
  if head > tail then return nil end
  local v = queue[head]
  queue[head] = nil
  head = head + 1
  return v
end

enqueue("a"); enqueue("b"); enqueue("c")
print(dequeue())  -- a
print(dequeue())  -- b

Operator Panjang #

Operator # mengembalikan "batas" sebuah tabel: indeks i sedemikian rupa sehingga t[i] ~= nil dan t[i+1] == nil. Untuk urutan tanpa celah, nilai ini sama dengan panjang larik. Jika terdapat celah (nil di tengah), hasil # tidak terdefinisi — gunakan table.pack atau catat panjangnya secara manual.

local t = {10, 20, 30, 40, 50}
print(#t)   -- 5

-- Safe for dense arrays
for i = #t, 1, -1 do
  io.write(t[i] .. " ")
end
print()  -- 50 40 30 20 10

Mengiris Larik

Lua tidak memiliki pengiris bawaan, tetapi Anda dapat mengekstrak sublarik dengan table.move (Lua 5.3+) atau perulangan manual. table.move(a1, f, e, t, a2) menyalin elemen dari a1[f..e] ke a2, dimulai pada posisi t.

local src = {10,20,30,40,50,60}

-- Manual slice
local function slice(t, from, to)
  local result = {}
  for i = from, to do
    result[#result+1] = t[i]
  end
  return result
end

local sub = slice(src, 2, 4)
print(sub[1], sub[2], sub[3])  -- 20  30  40

Membalik Larik

Balik tabel secara langsung dengan menukar elemen dari kedua ujung menuju tengah. Ini adalah algoritme klasik yang bekerja pada larik Lua apa pun tanpa memerlukan memori tambahan.

local function reverse(t)
  local n = #t
  for i = 1, math.floor(n / 2) do
    t[i], t[n - i + 1] = t[n - i + 1], t[i]
  end
end

local arr = {1, 2, 3, 4, 5}
reverse(arr)
for _, v in ipairs(arr) do
  io.write(v .. " ")
end
print()  -- 5 4 3 2 1

Menggabungkan Larik

Untuk menggabungkan dua larik menjadi satu, lakukan perulangan pada larik kedua dan tambahkan elemen-elemennya. table.move melakukannya secara efisien dalam Lua 5.3+. Hasilnya adalah tabel baru yang berisi semua elemen dari kedua larik dalam urutan yang sama.

local function concat(a, b)
  local result = {}
  for _, v in ipairs(a) do result[#result+1] = v end
  for _, v in ipairs(b) do result[#result+1] = v end
  return result
end

local merged = concat({1,2,3}, {4,5,6})
for i, v in ipairs(merged) do
  io.write(v .. " ")
end
print()  -- 1 2 3 4 5 6

Meratakan Larik Bersarang

Ratakan larik bersarang secara rekursif: jika suatu elemen adalah tabel, lakukan rekursi terhadapnya; jika tidak, tambahkan elemen tersebut ke hasil. Ini merupakan penerapan alami dari penelusuran tabel secara rekursif.

local function flatten(t, result)
  result = result or {}
  for _, v in ipairs(t) do
    if type(v) == "table" then
      flatten(v, result)
    else
      result[#result+1] = v
    end
  end
  return result
end

local nested = {1, {2, 3}, {4, {5, 6}}, 7}
local flat = flatten(nested)
print(table.concat(flat, ", "))  -- 1, 2, 3, 4, 5, 6, 7

Larik sebagai Set

Anda dapat menerapkan set menggunakan tabel, dengan nilai sebagai kunci dan nilainya berupa true. Pemeriksaan keanggotaan set memiliki kompleksitas O(1). Membuat set dari sebuah larik akan menghapus duplikatnya. Konversikan kembali menjadi larik dengan melakukan iterasi menggunakan pairs.

local function toSet(arr)
  local set = {}
  for _, v in ipairs(arr) do set[v] = true end
  return set
end

local nums = {3,1,4,1,5,9,2,6,5,3}
local set = toSet(nums)
local unique = {}
for k in pairs(set) do unique[#unique+1] = k end
table.sort(unique)
print(table.concat(unique, " "))  -- 1 2 3 4 5 6 9

Pemeriksaan Singkat

Apa yang dilakukan table.remove(t) jika dipanggil hanya dengan satu argumen?

Jawab di pelajaran interaktif

Ringkasan: Tabel sebagai Larik

Ringkasan:

Larik Lua adalah tabel dengan indeks mulai dari 1
table.insert/table.remove untuk menambahkan/mengambil elemen
#t memberikan panjang untuk urutan tanpa celah
Tumpukan: menyisipkan/menghapus dari akhir (O(1))
Antrean: gunakan penunjuk kepala+ekor agar tidak perlu menggeser dengan kompleksitas O(n)
Gunakan tabel sebagai set untuk pemeriksaan keanggotaan O(1)

Gratis untuk memulai

Belajar Lua dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 40
Pelajaran: 159

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Tabel sebagai Larik” gratis?

Ya — teks lengkap “Tabel sebagai Larik” 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 “Tabel sebagai Larik”?

Buat dan manipulasi larik berindeks mulai dari 1 dengan table.insert dan table.remove. 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 1 dari 4.

Berapa lama pelajaran “Tabel sebagai Larik” 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

Tabel sebagai Larik
Tabel sebagai Kamus
Melakukan Iterasi pada Tabel dengan pairs dan ipairs
Tabel Bertingkat dan Data Terstruktur

← Kembali ke Lua Academy