Object Oriented Programming in Lua

Object oriented programming in Lua uses the same concepts as OOP in other languages: classes, instances, methods, etc. The implementation of a class is done with plain Lua tables and functions, and (perhaps a new concept for you) metatables.

A quick example: let's create a Car class that can create new cars for a specified manufacturer

Car = {}
Car.__index = Car

function Car.new(class, manufacturer)
  local new_car = {}
  new_car.manufacturer = manufacturer
  setmetatable(new_car, class)
  return new_car
end

my_car = Car.new(Car, "Volvo")
print(my_car.manufacturer)   -- Volvo

We can see the class is just a table with one member, a function named new. The new function creates a table, adds a member to it, does some magic, and then returns the table. We will see what __index and setmetatable do a little further down. This "new" function is acting as the constructor for the class, creating a new instance.

my_car = Car.new(Car, "Volvo")

my_car = Car:new("Volvo")

function Car:new(manufacturer)
  local new_car = {}
  new_car.manufacturer = manufacturer
  setmetatable(new_car, self)         -- <<< here
  return new_car
end

Methods

We have a new car, but it can't do anything. Let's add a method to the class.

function Car:honk()
  print("The " .. self.manufacturer .. " car goes: beep!")
end

my_car:honk()       -- The Volvo car goes: beep!

How does the car instance know where to find the honk method? The Car "new" constructor did not add a honk function to the instance table.

Method lookup

This is where metatables come in to the picture.

It goes like this.

1. Does my_car have a honk member? No.
2. Does my_car have a metatable? Yes, we set the metatable for my_car to be Car.
3. Does the metatable have an __index element? Yes, we wrote Car.__index = Car
4. Does Car (the "metavalue" for the __index "metamethod") have a honk member? Yes!

This is how my_car:honk() can be resolved to Car.honk(my_car).

See this guide for more details about metatables.

Inheritance

We can add a base class for Car by setting a metatable on the class, expanding the method lookup path.

Vehicle = {}
Vehicle.__index = Vehicle

setmetatable(Car, Vehicle)

function Vehicle:drive()
  print("The " .. self.manufacturer .. " vehicle advances.")
end

my_car:drive()         -- The Volvo vehicle advances.

Alternate instance construction

Sometimes you might prefer to construct an instance without a specific new method. You might prefer to write it this way.

my_other_car = Car("Porsche")

Lua "metamethods" can do this. We need to tell Lua what to do when someone calls the Car table.

We do this by adding a __call element to Car's metatable, and the value for __call will be a function

Vehicle.__call = function(class, ...) return class:new(...) end

Now:

my_other_car = Car("Porsche")
my_other_car:drive()        -- The Porsche vehicle advances.

Summary

To create a class, you can use this 6-step convention.

-- A Robot module

local Robot = {}        -- 1. name the class
Robot.__index = Robot   -- 2. set the index for the class

function Robot:new(attributes)
  local robot = {}    -- 3. name the new instance

  -- 4. set the metatable
  --    since `new` is called on the class, `self` is the class
  setmetatable(robot, self)

  -- 5. do stuff with the attributes
  robot.name = attributes.name or "Anonymous"

  -- `robot` is a "proper" instance now, so it's OK to call methods on it here.

  return robot        -- 6. return the new instance
end

local my_robot = Robot:new({ name = "Robbie" })

return Robot

Read more details in the (sadly archived) LuaUsersWiki.