Table Library in Lua

Beginner ~25 min read

Lua provides a powerful table library with built-in functions for manipulating tables efficiently. These functions handle common operations like inserting, removing, sorting, and joining table elements. Mastering the table library will make your code cleaner and more efficient. Let's explore all the essential table functions!

table.insert()

Insert elements into a table:

local fruits = {"apple", "banana"}

-- Insert at end
table.insert(fruits, "cherry")
-- fruits = {"apple", "banana", "cherry"}

-- Insert at specific position
table.insert(fruits, 2, "blueberry")
-- fruits = {"apple", "blueberry", "banana", "cherry"}

Syntax:

table.insert(t, value) - Append to end
table.insert(t, pos, value) - Insert at position

-- Table Library Functions in Lua

local fruits = {"apple", "banana", "cherry"}

-- table.insert() - Add elements
print("=== table.insert() ===")
table.insert(fruits, "date")  -- Append to end
print("After insert:", table.concat(fruits, ", "))

table.insert(fruits, 2, "blueberry")  -- Insert at position 2
print("After insert at 2:", table.concat(fruits, ", "))

-- table.remove() - Remove elements
print("\n=== table.remove() ===")
local removed = table.remove(fruits)  -- Remove last
print("Removed:", removed)
print("After remove:", table.concat(fruits, ", "))

local removed2 = table.remove(fruits, 2)  -- Remove at position 2
print("Removed at 2:", removed2)
print("After remove at 2:", table.concat(fruits, ", "))

-- table.concat() - Join array elements
print("\n=== table.concat() ===")
local numbers = {1, 2, 3, 4, 5}
print("Concat with comma:", table.concat(numbers, ", "))
print("Concat with dash:", table.concat(numbers, " - "))
print("Concat no separator:", table.concat(numbers))

-- table.sort() - Sort array
print("\n=== table.sort() ===")
local unsorted = {5, 2, 8, 1, 9, 3}
table.sort(unsorted)
print("Sorted ascending:", table.concat(unsorted, ", "))

table.sort(unsorted, function(a, b) return a > b end)
print("Sorted descending:", table.concat(unsorted, ", "))

-- table.unpack() - Unpack array to variables
print("\n=== table.unpack() ===")
local coords = {10, 20, 30}
local x, y, z = table.unpack(coords)
print("x:", x, "y:", y, "z:", z)

-- table.pack() - Pack values into array (Lua 5.2+)
print("\n=== table.pack() ===")
local packed = table.pack(1, 2, 3, 4, 5)
print("Packed:", table.concat(packed, ", "))
print("Count:", packed.n)

-- table.move() - Copy elements (Lua 5.3+)
print("\n=== table.move() ===")
local source = {10, 20, 30, 40, 50}
local dest = {}
table.move(source, 1, 3, 1, dest)  -- Copy first 3 elements
print("Moved:", table.concat(dest, ", "))

-- Practical examples
print("\n=== Practical Examples ===")

-- Stack operations
local stack = {}
table.insert(stack, "first")
table.insert(stack, "second")
table.insert(stack, "third")
print("Stack:", table.concat(stack, ", "))
print("Pop:", table.remove(stack))
print("After pop:", table.concat(stack, ", "))

-- Queue operations
local queue = {}
table.insert(queue, "task1")
table.insert(queue, "task2")
table.insert(queue, "task3")
print("\nQueue:", table.concat(queue, ", "))
print("Dequeue:", table.remove(queue, 1))
print("After dequeue:", table.concat(queue, ", "))

-- Reverse array
local function reverse(arr)
    local reversed = {}
    for i = #arr, 1, -1 do
        table.insert(reversed, arr[i])
    end
    return reversed
end

local original = {1, 2, 3, 4, 5}
local rev = reverse(original)
print("\nOriginal:", table.concat(original, ", "))
print("Reversed:", table.concat(rev, ", "))

-- Clear array
local function clear(arr)
    for i = #arr, 1, -1 do
        table.remove(arr)
    end
end

local temp = {1, 2, 3}
print("\nBefore clear:", table.concat(temp, ", "))
clear(temp)
print("After clear: length =", #temp)

Output

Click Run to execute your code

table.remove()

Remove elements from a table:

local fruits = {"apple", "banana", "cherry", "date"}

-- Remove last element
local removed = table.remove(fruits)
print(removed)  -- "date"
-- fruits = {"apple", "banana", "cherry"}

-- Remove at specific position
local removed = table.remove(fruits, 2)
print(removed)  -- "banana"
-- fruits = {"apple", "cherry"}

Important: table.remove() shifts elements to fill the gap. Removing from the beginning or middle is O(n) complexity!

-- Table Library Functions in Lua

local fruits = {"apple", "banana", "cherry"}

-- table.insert() - Add elements
print("=== table.insert() ===")
table.insert(fruits, "date")  -- Append to end
print("After insert:", table.concat(fruits, ", "))

table.insert(fruits, 2, "blueberry")  -- Insert at position 2
print("After insert at 2:", table.concat(fruits, ", "))

local removed2 = table.remove(fruits, 2)  -- Remove at position 2
print("Removed at 2:", removed2)
print("After remove at 2:", table.concat(fruits, ", "))

-- table.sort() - Sort array
print("\n=== table.sort() ===")
local unsorted = {5, 2, 8, 1, 9, 3}
table.sort(unsorted)
print("Sorted ascending:", table.concat(unsorted, ", "))

table.sort(unsorted, function(a, b) return a > b end)
print("Sorted descending:", table.concat(unsorted, ", "))

-- table.unpack() - Unpack array to variables
print("\n=== table.unpack() ===")
local coords = {10, 20, 30}
local x, y, z = table.unpack(coords)
print("x:", x, "y:", y, "z:", z)

-- table.pack() - Pack values into array (Lua 5.2+)
print("\n=== table.pack() ===")
local packed = table.pack(1, 2, 3, 4, 5)
print("Packed:", table.concat(packed, ", "))
print("Count:", packed.n)

-- Practical examples
print("\n=== Practical Examples ===")

-- Reverse array
local function reverse(arr)
    local reversed = {}
    for i = #arr, 1, -1 do
        table.insert(reversed, arr[i])
    end
    return reversed
end

local original = {1, 2, 3, 4, 5}
local rev = reverse(original)
print("\nOriginal:", table.concat(original, ", "))
print("Reversed:", table.concat(rev, ", "))

-- Clear array
local function clear(arr)
    for i = #arr, 1, -1 do
        table.remove(arr)
    end
end

local temp = {1, 2, 3}
print("\nBefore clear:", table.concat(temp, ", "))
clear(temp)
print("After clear: length =", #temp)

Output

Click Run to execute your code

table.sort()

Sort table elements in-place:

local numbers = {5, 2, 8, 1, 9, 3}

-- Sort ascending (default)
table.sort(numbers)
-- numbers = {1, 2, 3, 5, 8, 9}

-- Sort descending with custom comparator
table.sort(numbers, function(a, b)
    return a > b
end)
-- numbers = {9, 8, 5, 3, 2, 1}

-- Sort strings
local names = {"Charlie", "Alice", "Bob"}
table.sort(names)
-- names = {"Alice", "Bob", "Charlie"}

Custom Sorting

local people = {
    {name = "Alice", age = 25},
    {name = "Bob", age = 30},
    {name = "Charlie", age = 20}
}

-- Sort by age
table.sort(people, function(a, b)
    return a.age < b.age
end)
-- Charlie (20), Alice (25), Bob (30)

-- Sorting Tables in Lua

-- Basic numeric sort
print("=== Basic Numeric Sort ===")
local numbers = {5, 2, 8, 1, 9, 3, 7, 4, 6}
table.sort(numbers)
print("Ascending:", table.concat(numbers, ", "))

table.sort(numbers, function(a, b) return a > b end)
print("Descending:", table.concat(numbers, ", "))

-- String sort
print("\n=== String Sort ===")
local names = {"Charlie", "Alice", "Bob", "David"}
table.sort(names)
print("Alphabetical:", table.concat(names, ", "))

table.sort(names, function(a, b) return a > b end)
print("Reverse:", table.concat(names, ", "))

-- Case-insensitive sort
print("\n=== Case-Insensitive Sort ===")
local mixed = {"apple", "Banana", "cherry", "Date"}
table.sort(mixed, function(a, b)
    return string.lower(a) < string.lower(b)
end)
print("Case-insensitive:", table.concat(mixed, ", "))

-- Sort by length
print("\n=== Sort by Length ===")
local words = {"cat", "elephant", "dog", "butterfly", "ant"}
table.sort(words, function(a, b)
    return #a < #b
end)
print("By length:", table.concat(words, ", "))

-- Sort table of tables
print("\n=== Sort Table of Tables ===")
local students = {
    {name = "Alice", grade = 85},
    {name = "Bob", grade = 92},
    {name = "Charlie", grade = 78},
    {name = "David", grade = 95}
}

-- Sort by grade
table.sort(students, function(a, b)
    return a.grade > b.grade
end)

print("Sorted by grade:")
for i, student in ipairs(students) do
    print(i .. ".", student.name, "-", student.grade)
end

-- Sort by name
table.sort(students, function(a, b)
    return a.name < b.name
end)

print("\nSorted by name:")
for i, student in ipairs(students) do
    print(i .. ".", student.name, "-", student.grade)
end

-- Multi-level sort (by grade, then by name)
print("\n=== Multi-Level Sort ===")
local data = {
    {name = "Alice", grade = 85, age = 20},
    {name = "Bob", grade = 85, age = 22},
    {name = "Charlie", grade = 92, age = 21},
    {name = "David", grade = 85, age = 19}
}

table.sort(data, function(a, b)
    if a.grade == b.grade then
        return a.name < b.name  -- Secondary sort by name
    end
    return a.grade > b.grade  -- Primary sort by grade
end)

print("Sorted by grade, then name:")
for i, item in ipairs(data) do
    print(string.format("%d. %s - Grade: %d, Age: %d", 
        i, item.name, item.grade, item.age))
end

-- Stable sort (preserve original order for equal elements)
print("\n=== Custom Stable Sort ===")
local items = {
    {id = 1, value = 5},
    {id = 2, value = 3},
    {id = 3, value = 5},
    {id = 4, value = 3},
    {id = 5, value = 7}
}

-- Add original index for stability
for i, item in ipairs(items) do
    item.originalIndex = i
end

table.sort(items, function(a, b)
    if a.value == b.value then
        return a.originalIndex < b.originalIndex
    end
    return a.value < b.value
end)

print("Stable sort by value:")
for i, item in ipairs(items) do
    print(string.format("ID: %d, Value: %d", item.id, item.value))
end

-- Sort with custom comparison
print("\n=== Custom Comparison ===")
local points = {
    {x = 3, y = 4},
    {x = 1, y = 2},
    {x = 5, y = 1},
    {x = 2, y = 3}
}

-- Sort by distance from origin
table.sort(points, function(a, b)
    local distA = math.sqrt(a.x^2 + a.y^2)
    local distB = math.sqrt(b.x^2 + b.y^2)
    return distA < distB
end)

print("Sorted by distance from origin:")
for i, p in ipairs(points) do
    local dist = math.sqrt(p.x^2 + p.y^2)
    print(string.format("(%d, %d) - distance: %.2f", p.x, p.y, dist))
end

Output

Click Run to execute your code

table.concat()

Join table elements into a string:

local words = {"Hello", "World", "Lua"}

-- Join with default separator (empty string)
local result = table.concat(words)
print(result)  -- "HelloWorldLua"

-- Join with custom separator
local result = table.concat(words, " ")
print(result)  -- "Hello World Lua"

-- Join with separator and range
local result = table.concat(words, ", ", 1, 2)
print(result)  -- "Hello, World"

Best Practice: Use table.concat() instead of string concatenation in loops—it's much faster for building long strings!

-- Table Library Functions in Lua

local fruits = {"apple", "banana", "cherry"}

-- table.insert() - Add elements
print("=== table.insert() ===")
table.insert(fruits, "date")  -- Append to end
print("After insert:", table.concat(fruits, ", "))

table.insert(fruits, 2, "blueberry")  -- Insert at position 2
print("After insert at 2:", table.concat(fruits, ", "))

local removed2 = table.remove(fruits, 2)  -- Remove at position 2
print("Removed at 2:", removed2)
print("After remove at 2:", table.concat(fruits, ", "))

-- table.sort() - Sort array
print("\n=== table.sort() ===")
local unsorted = {5, 2, 8, 1, 9, 3}
table.sort(unsorted)
print("Sorted ascending:", table.concat(unsorted, ", "))

table.sort(unsorted, function(a, b) return a > b end)
print("Sorted descending:", table.concat(unsorted, ", "))

-- table.unpack() - Unpack array to variables
print("\n=== table.unpack() ===")
local coords = {10, 20, 30}
local x, y, z = table.unpack(coords)
print("x:", x, "y:", y, "z:", z)

-- table.pack() - Pack values into array (Lua 5.2+)
print("\n=== table.pack() ===")
local packed = table.pack(1, 2, 3, 4, 5)
print("Packed:", table.concat(packed, ", "))
print("Count:", packed.n)

-- Practical examples
print("\n=== Practical Examples ===")

-- Reverse array
local function reverse(arr)
    local reversed = {}
    for i = #arr, 1, -1 do
        table.insert(reversed, arr[i])
    end
    return reversed
end

local original = {1, 2, 3, 4, 5}
local rev = reverse(original)
print("\nOriginal:", table.concat(original, ", "))
print("Reversed:", table.concat(rev, ", "))

-- Clear array
local function clear(arr)
    for i = #arr, 1, -1 do
        table.remove(arr)
    end
end

local temp = {1, 2, 3}
print("\nBefore clear:", table.concat(temp, ", "))
clear(temp)
print("After clear: length =", #temp)

Output

Click Run to execute your code

table.pack() and table.unpack()

table.pack() - Lua 5.2+

Pack values into a table:

local packed = table.pack(10, 20, 30)
-- packed = {10, 20, 30, n = 3}
-- 'n' field stores the count

print(packed[1])  -- 10
print(packed.n)   -- 3

table.unpack() (or unpack in Lua 5.1)

Unpack table into multiple values:

local numbers = {10, 20, 30}

-- Unpack all values
local a, b, c = table.unpack(numbers)
print(a, b, c)  -- 10  20  30

-- Unpack range
local x, y = table.unpack(numbers, 1, 2)
print(x, y)  -- 10  20

-- Use in function calls
local function add(a, b, c)
    return a + b + c
end

print(add(table.unpack(numbers)))  -- 60

-- Table Library Functions in Lua

local fruits = {"apple", "banana", "cherry"}

-- table.insert() - Add elements
print("=== table.insert() ===")
table.insert(fruits, "date")  -- Append to end
print("After insert:", table.concat(fruits, ", "))

table.insert(fruits, 2, "blueberry")  -- Insert at position 2
print("After insert at 2:", table.concat(fruits, ", "))

local removed2 = table.remove(fruits, 2)  -- Remove at position 2
print("Removed at 2:", removed2)
print("After remove at 2:", table.concat(fruits, ", "))

-- table.sort() - Sort array
print("\n=== table.sort() ===")
local unsorted = {5, 2, 8, 1, 9, 3}
table.sort(unsorted)
print("Sorted ascending:", table.concat(unsorted, ", "))

table.sort(unsorted, function(a, b) return a > b end)
print("Sorted descending:", table.concat(unsorted, ", "))

-- table.unpack() - Unpack array to variables
print("\n=== table.unpack() ===")
local coords = {10, 20, 30}
local x, y, z = table.unpack(coords)
print("x:", x, "y:", y, "z:", z)

-- table.pack() - Pack values into array (Lua 5.2+)
print("\n=== table.pack() ===")
local packed = table.pack(1, 2, 3, 4, 5)
print("Packed:", table.concat(packed, ", "))
print("Count:", packed.n)

-- Practical examples
print("\n=== Practical Examples ===")

-- Reverse array
local function reverse(arr)
    local reversed = {}
    for i = #arr, 1, -1 do
        table.insert(reversed, arr[i])
    end
    return reversed
end

local original = {1, 2, 3, 4, 5}
local rev = reverse(original)
print("\nOriginal:", table.concat(original, ", "))
print("Reversed:", table.concat(rev, ", "))

-- Clear array
local function clear(arr)
    for i = #arr, 1, -1 do
        table.remove(arr)
    end
end

local temp = {1, 2, 3}
print("\nBefore clear:", table.concat(temp, ", "))
clear(temp)
print("After clear: length =", #temp)

Output

Click Run to execute your code

Practical Examples

Building a CSV String

local function toCSV(rows)
    local lines = {}
    for i, row in ipairs(rows) do
        table.insert(lines, table.concat(row, ","))
    end
    return table.concat(lines, "\n")
end

local data = {
    {"Name", "Age", "City"},
    {"Alice", "25", "NYC"},
    {"Bob", "30", "LA"}
}

print(toCSV(data))

Stack Implementation

local Stack = {}

function Stack:new()
    local stack = {items = {}}
    setmetatable(stack, {__index = self})
    return stack
end

function Stack:push(value)
    table.insert(self.items, value)
end

function Stack:pop()
    return table.remove(self.items)
end

function Stack:peek()
    return self.items[#self.items]
end

function Stack:isEmpty()
    return #self.items == 0
end

local s = Stack:new()
s:push(10)
s:push(20)
print(s:pop())  -- 20

Queue Implementation

local Queue = {}

function Queue:new()
    local queue = {items = {}}
    setmetatable(queue, {__index = self})
    return queue
end

function Queue:enqueue(value)
    table.insert(self.items, value)
end

function Queue:dequeue()
    return table.remove(self.items, 1)
end

local q = Queue:new()
q:enqueue("first")
q:enqueue("second")
print(q:dequeue())  -- "first"

-- Table Manipulation Techniques

-- Deep copy (recursive)
local function deepCopy(original)
    if type(original) ~= "table" then
        return original
    end
    
    local copy = {}
    for k, v in pairs(original) do
        copy[k] = deepCopy(v)  -- Recursive copy
    end
    return copy
end

local original = {a = 1, b = {c = 2, d = 3}}
local copy = deepCopy(original)
copy.b.c = 999

print("=== Deep Copy ===")
print("Original b.c:", original.b.c)  -- 2 (unchanged)
print("Copy b.c:", copy.b.c)          -- 999

-- Merge tables
local function merge(t1, t2)
    local result = {}
    for k, v in pairs(t1) do
        result[k] = v
    end
    for k, v in pairs(t2) do
        result[k] = v  -- Overwrites if exists
    end
    return result
end

print("\n=== Merge Tables ===")
local defaults = {theme = "dark", lang = "en", size = 12}
local settings = {theme = "light", size = 14}
local config = merge(defaults, settings)

for k, v in pairs(config) do
    print(k, "=", v)
end

-- Filter table
local function filter(tbl, predicate)
    local result = {}
    for i, v in ipairs(tbl) do
        if predicate(v) then
            table.insert(result, v)
        end
    end
    return result
end

print("\n=== Filter ===")
local numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
local evens = filter(numbers, function(x) return x % 2 == 0 end)
print("Evens:", table.concat(evens, ", "))

-- Map table
local function map(tbl, func)
    local result = {}
    for i, v in ipairs(tbl) do
        result[i] = func(v)
    end
    return result
end

print("\n=== Map ===")
local squared = map(numbers, function(x) return x * x end)
print("Squared:", table.concat(squared, ", "))

-- Reduce table
local function reduce(tbl, func, initial)
    local acc = initial
    for i, v in ipairs(tbl) do
        acc = func(acc, v)
    end
    return acc
end

print("\n=== Reduce ===")
local sum = reduce(numbers, function(acc, x) return acc + x end, 0)
print("Sum:", sum)

-- Find in table
local function find(tbl, predicate)
    for i, v in ipairs(tbl) do
        if predicate(v) then
            return v, i
        end
    end
    return nil
end

print("\n=== Find ===")
local found, index = find(numbers, function(x) return x > 5 end)
print("First > 5:", found, "at index", index)

-- Count occurrences
local function count(tbl, value)
    local c = 0
    for i, v in ipairs(tbl) do
        if v == value then
            c = c + 1
        end
    end
    return c
end

print("\n=== Count ===")
local items = {1, 2, 3, 2, 4, 2, 5}
print("Count of 2:", count(items, 2))

-- Remove duplicates
local function unique(tbl)
    local seen = {}
    local result = {}
    for i, v in ipairs(tbl) do
        if not seen[v] then
            seen[v] = true
            table.insert(result, v)
        end
    end
    return result
end

print("\n=== Unique ===")
local duplicates = {1, 2, 3, 2, 4, 3, 5, 1}
local uniq = unique(duplicates)
print("Unique:", table.concat(uniq, ", "))

-- Flatten nested table
local function flatten(tbl)
    local result = {}
    for i, v in ipairs(tbl) do
        if type(v) == "table" then
            for j, inner in ipairs(flatten(v)) do
                table.insert(result, inner)
            end
        else
            table.insert(result, v)
        end
    end
    return result
end

print("\n=== Flatten ===")
local nested = {1, {2, 3}, {4, {5, 6}}, 7}
local flat = flatten(nested)
print("Flattened:", table.concat(flat, ", "))

-- Group by
local function groupBy(tbl, keyFunc)
    local groups = {}
    for i, v in ipairs(tbl) do
        local key = keyFunc(v)
        if not groups[key] then
            groups[key] = {}
        end
        table.insert(groups[key], v)
    end
    return groups
end

print("\n=== Group By ===")
local words = {"apple", "ant", "banana", "bear", "cat", "cherry"}
local grouped = groupBy(words, function(w) return string.sub(w, 1, 1) end)

for letter, group in pairs(grouped) do
    print(letter .. ":", table.concat(group, ", "))
end

-- Chunk array
local function chunk(tbl, size)
    local chunks = {}
    for i = 1, #tbl, size do
        local chunk = {}
        for j = i, math.min(i + size - 1, #tbl) do
            table.insert(chunk, tbl[j])
        end
        table.insert(chunks, chunk)
    end
    return chunks
end

print("\n=== Chunk ===")
local data = {1, 2, 3, 4, 5, 6, 7, 8, 9}
local chunks = chunk(data, 3)
for i, c in ipairs(chunks) do
    print("Chunk " .. i .. ":", table.concat(c, ", "))
end

Output

Click Run to execute your code

Quick Reference

Function	Purpose	Example
`table.insert(t, v)`	Append value	`table.insert(arr, 10)`
`table.insert(t, i, v)`	Insert at position	`table.insert(arr, 2, 10)`
`table.remove(t)`	Remove last	`table.remove(arr)`
`table.remove(t, i)`	Remove at position	`table.remove(arr, 2)`
`table.sort(t)`	Sort ascending	`table.sort(arr)`
`table.sort(t, comp)`	Sort with comparator	`table.sort(arr, function(a,b) return a>b end)`
`table.concat(t, sep)`	Join to string	`table.concat(arr, ", ")`
`table.unpack(t)`	Unpack values	`a, b = table.unpack(arr)`

Practice Exercise

Try these table library challenges:

-- Table Exercises

-- Exercise 1: Create and access tables
print("=== Exercise 1: Table Creation ===")
-- TODO: Create a table with your information
local person = {
    name = "John Doe",
    age = 25,
    city = "New York"
}

print("Name:", person.name)
print("Age:", person.age)
print("City:", person.city)

-- Exercise 2: Array operations
print("\n=== Exercise 2: Arrays ===")
local colors = {"red", "green", "blue"}
-- TODO: Add "yellow" to the array
colors[4] = "yellow"
-- TODO: Print the length
print("Number of colors:", #colors)
-- TODO: Print all colors
for i, color in ipairs(colors) do
    print(i, color)
end

-- Exercise 3: Nested tables
print("\n=== Exercise 3: Nested Tables ===")
local company = {
    name = "TechCorp",
    employees = {
        {name = "Alice", role = "Developer"},
        {name = "Bob", role = "Designer"},
        {name = "Charlie", role = "Manager"}
    }
}

-- TODO: Print all employee names
for i, emp in ipairs(company.employees) do
    print(string.format("%d. %s - %s", i, emp.name, emp.role))
end

-- Exercise 4: Table as dictionary
print("\n=== Exercise 4: Dictionary ===")
local inventory = {
    apples = 10,
    bananas = 5,
    oranges = 8
}

-- TODO: Add grapes with quantity 12
inventory.grapes = 12

-- TODO: Update apples to 15
inventory.apples = 15

-- TODO: Print all items
for item, quantity in pairs(inventory) do
    print(item, quantity)
end

-- Exercise 5: Mixed tables
print("\n=== Exercise 5: Mixed Tables ===")
local mixed = {
    10, 20, 30,  -- array part
    name = "Mixed Table",  -- hash part
    active = true
}

-- TODO: Access both parts
print("First element:", mixed[1])
print("Name:", mixed.name)
print("Active:", mixed.active)

-- Exercise 6: Table manipulation
print("\n=== Exercise 6: Table Manipulation ===")
local numbers = {5, 10, 15, 20, 25}

-- TODO: Double all numbers
for i = 1, #numbers do
    numbers[i] = numbers[i] * 2
end

print("Doubled:", table.concat(numbers, ", "))

-- Exercise 7: Table copying
print("\n=== Exercise 7: Shallow Copy ===")
local original = {a = 1, b = 2, c = 3}
local copy = {}

-- TODO: Copy all key-value pairs
for k, v in pairs(original) do
    copy[k] = v
end

copy.d = 4  -- Add to copy
print("Original has 'd':", original.d)  -- nil
print("Copy has 'd':", copy.d)  -- 4

-- Exercise 8: Table as set
print("\n=== Exercise 8: Set Operations ===")
local set = {}

-- TODO: Add elements to set
local items = {"apple", "banana", "apple", "cherry", "banana"}
for _, item in ipairs(items) do
    set[item] = true
end

-- TODO: Print unique items
print("Unique items:")
for item in pairs(set) do
    print("-", item)
end

-- Exercise 9: Count elements
print("\n=== Exercise 9: Counting ===")
local data = {a = 1, b = 2, c = 3, d = 4, e = 5}

-- TODO: Count how many key-value pairs
local count = 0
for _ in pairs(data) do
    count = count + 1
end

print("Number of pairs:", count)

-- Exercise 10: Table filtering
print("\n=== Exercise 10: Filtering ===")
local all_numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
local even_numbers = {}

-- TODO: Filter only even numbers
for _, num in ipairs(all_numbers) do
    if num % 2 == 0 then
        table.insert(even_numbers, num)
    end
end

print("Even numbers:", table.concat(even_numbers, ", "))

print("\n=== All Exercises Complete ===")

Output

Click Run to execute your code

Summary

In this lesson, you learned:

table.insert() for adding elements
table.remove() for removing elements
table.sort() for sorting with custom comparators
table.concat() for efficient string building
table.pack() and table.unpack() for value manipulation
Practical implementations: CSV, Stack, Queue

What's Next?

You've mastered the table library! Next, we'll explore metatables—one of Lua's most powerful features. Metatables let you customize table behavior, overload operators, and create sophisticated object-oriented patterns. Let's continue! 🚀

Previous Tables

Next Metatables

table.insert()

table.remove()

table.sort()

Custom Sorting

table.concat()

table.pack() and table.unpack()

table.pack() - Lua 5.2+

table.unpack() (or unpack in Lua 5.1)

Practical Examples

Building a CSV String

Stack Implementation

Queue Implementation

Quick Reference

Practice Exercise

Summary

What's Next?

Enjoying these tutorials?