PricingLoginStart free
Lua Academy · Lesson

Deep Copy and Shallow Copy

Implement recursive deep copy and understand reference semantics.

Lesson 3 of 413 steps

Deep Copy and Shallow Copy is a free Lua Academy lesson on CoddyKit. This is lesson 3 of 4. Any 3 lessons of this learning path are free to read in full — after that, CoddyKit PRO unlocks every lesson, plus hands-on practice with a built-in code editor and a 24/7 AI tutor. It is part of the Lua Academy learning path, and your progress syncs across the web and the CoddyKit app. The Lua Academy course includes 4 lessons in total.

Reference Semantics in Lua

In Lua, assigning a table to another variable copies the reference, not the data. Both variables point to the same table.

local a = {1, 2, 3}
local b = a
b[1] = 99
print(a[1])  -- 99, a is affected!

Shallow Copy

A shallow copy creates a new table with the same top-level keys and values. Nested tables are still shared.

local function shallowCopy(t)
  local copy = {}
  for k, v in pairs(t) do copy[k] = v end
  return copy
end

Shallow Copy Limitation

Modifying a nested table in a shallow copy affects the original.

local orig = {data = {1, 2, 3}}
local sc = shallowCopy(orig)
sc.data[1] = 99
print(orig.data[1])  -- 99 (shared!)

Deep Copy via Recursion

A deep copy recursively duplicates every nested table, breaking all shared references.

local function deepCopy(orig)
  local copy
  if type(orig) == "table" then
    copy = {}
    for k, v in pairs(orig) do
      copy[deepCopy(k)] = deepCopy(v)
    end
    setmetatable(copy, getmetatable(orig))
  else
    copy = orig
  end
  return copy
end

Deep Copy in Action

After a deep copy, modifying nested tables in the copy leaves the original untouched.

local orig = {data = {1, 2, 3}}
local dc = deepCopy(orig)
dc.data[1] = 99
print(orig.data[1])  -- 1 (independent!)

Handling Cycles

Naive deep copy breaks on cyclic tables. Track visited tables in a memo table to handle cycles.

local function deepCopyMemo(orig, memo)
  memo = memo or {}
  if type(orig) ~= "table" then return orig end
  if memo[orig] then return memo[orig] end
  local copy = {}
  memo[orig] = copy
  for k, v in pairs(orig) do
    copy[deepCopyMemo(k, memo)] = deepCopyMemo(v, memo)
  end
  setmetatable(copy, getmetatable(orig))
  return copy
end

Copying Metatables

Deep copy should also transfer the metatable with setmetatable(copy, getmetatable(orig)) to preserve OOP behavior.

Shallow Copy with table.move

For sequential arrays a fast shallow clone uses table.move.

local function arrayCopy(t)
  return table.move(t, 1, #t, 1, {})
end

When to Use Each

  • Shallow: simple flat tables, performance-critical cloning.
  • Deep: nested structures, serialization, immutable snapshots.

Function Values

Functions are never copied — both shallow and deep copy share the same function reference. This is usually the desired behavior.

Performance Considerations

Deep copy is O(n) in the number of nodes. For very large trees, consider structural sharing or copy-on-write patterns instead.

Copy Type Question

After a shallow copy, what happens when you modify a nested table in the copy?

Answer it in the interactive lesson

Recap: Deep vs Shallow Copy

Shallow copy duplicates top-level keys only; nested tables are shared. Deep copy recursively duplicates everything. Handle cycles with a memo table to prevent infinite recursion.

Free to start

Learn Lua with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses
40
Lessons
159
Start learning freeView the full course

Frequently Asked Questions

Is the “Deep Copy and Shallow Copy” lesson free?

Yes — any 3 lessons of the Lua Academy learning path, including “Deep Copy and Shallow Copy”, are free to read in full here on the web. After that, CoddyKit PRO unlocks every lesson, plus interactive practice with a built-in code editor and a 24/7 AI tutor. The Lua Academy course includes 4 lessons in total.

What will I learn in “Deep Copy and Shallow Copy”?

Implement recursive deep copy and understand reference semantics. You practise Lua Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Lua Academy?

No prior experience is required. Lua Academy on CoddyKit is structured for beginners through advanced learners, so you can start here or from the beginning and move at your own pace. This is lesson 3 of 4.

How long does the “Deep Copy and Shallow Copy” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Lua Academy lesson?

Yes. Every Lua Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. table.sort with Comparators
  2. table.concat and table.move
  3. Deep Copy and Shallow Copy
  4. Transforming Tables: map, filter, reduce
← Back to Lua Academy