
- Lua Tutorial
- Lua - Home
- Lua Basics
- Lua - Overview
- Lua - Environment
- Lua - Basic Syntax
- Lua - Comments
- Lua - Print Hello World
- Lua - Variables
- Lua - Data Types
- Lua - Operators
- Lua - Loops
- Lua - Generic For
- Lua - Decision Making
- Lua - Date and Time
- Lua Functions
- Lua - Functions
- Lua - Multiple Results
- Lua - Named Arguments
- Lua - Default/Optional Arguments
- Lua - Closures
- Lua - Uses of Closures
- Lua - Local Functions
- Lua - Anonymous Functions
- Lua - Functions in Table
- Lua - Proper Tail Calls
- Lua Strings
- Lua - Strings
- Lua - String Concatenation
- Lua - Loop Through String
- Lua - String to Int
- Lua - Split String
- Lua - Check String is NULL
- Lua Arrays
- Lua - Arrays
- Lua - Multi-dimensional Arrays
- Lua - Array Length
- Lua - Iterating Over Arrays
- Lua - Slicing Arrays
- Lua - Sorting Arrays
- Lua - Merging Arrays
- Lua - Sparse Arrays
- Lua - Searching Arrays
- Lua - Resizing Arrays
- Lua - Array to String Conversion
- Lua - Array as Stack
- Lua - Array as Queue
- Lua - Array with Metatables
- Lua - Immutable Arrays
- Lua - Shuffling Arrays
- Lua Iterators
- Lua - Iterators
- Lua - Stateless Iterators
- Lua - Stateful Iterators
- Lua - Built-in Iterators
- Lua - Custom Iterators
- Lua - Iterator Closures
- Lua - Infinite Iterators
- Lua - File Iterators
- Lua - Table Iterators
- Lua - Numeric Iterators
- Lua - Reverse Iterators
- Lua - Filter Iterators
- Lua - Range Iterators
- Lua - Chaining Iterators
- Lua Tables
- Lua - Tables
- Lua - Tables as Arrays
- Lua - Tables as Dictionaries
- Lua - Tables as Sets
- Lua - Table Length
- Lua - Table Iteration
- Lua - Table Constructors
- Lua - Loop through Table
- Lua - Merge Tables
- Lua - Nested Tables
- Lua - Accessing Table Fields
- Lua - Copy Table by Value
- Lua - Get Entries from Table
- Lua - Table Metatables
- Lua - Tables as Objects
- Lua - Table Inheritance
- Lua - Table Cloning
- Lua - Table Sorting
- Lua - Table Searching
- Lua - Table Serialization
- Lua - Weak Tables
- Lua - Table Memory Management
- Lua - Tables as Stacks
- Lua - Tables as Queues
- Lua - Sparse Tables
- Lua Lists
- Lua - Lists
- Lua - Inserting Elements into Lists
- Lua - Removing Elements from Lists
- Lua - Iterating Over Lists
- Lua - Reverse Iterating Over Lists
- Lua - Accessing List Elements
- Lua - Modifying List Elements
- Lua - List Length
- Lua - Concatenate Lists
- Lua - Slicing Lists
- Lua - Sorting Lists
- Lua - Reversing Lists
- Lua - Searching in Lists
- Lua - Shuffling List
- Lua - Multi-dimensional Lists
- Lua - Sparse Lists
- Lua - Lists as Stacks
- Lua - Lists as Queues
- Lua - Functional Operations on Lists
- Lua - Immutable Lists
- Lua - List Serialization
- Lua - Metatables with Lists
- Lua Modules
- Lua - Modules
- Lua - Returning Functions from Modules
- Lua - Returning Functions Table from Modules
- Lua - Module Scope
- Lua - SubModule
- Lua - Module Caching
- Lua - Custom Module Loaders
- Lua - Namespaces
- Lua - Singleton Modules
- Lua - Sharing State Between Modules
- Lua - Module Versioning
- Lua Metatables
- Lua - Metatables
- Lua - Chaining Metatables
- Lua Coroutines
- Lua - Coroutines
- Lua File Handling
- Lua - File I/O
- Lua - Opening Files
- Lua - Modes for File Access
- Lua - Reading Files
- Lua - Writing Files
- Lua - Closing Files
- Lua - Renaming Files
- Lua - Deleting Files
- Lua - File Buffers and Flushing
- Lua - Reading Files Line by Line
- Lua - Binary File Handling
- Lua - File Positioning
- Lua - Appending to Files
- Lua - Error Handling in File Operations
- Lua - Checking if File exists
- Lua - Checking if File is Readable
- Lua - Checking if File is Writable
- Lua - Checking if File is ReadOnly
- Lua - File Descriptors
- Lua - Creating Temporary Files
- Lua - Working with Large Files
- Lua Advanced
- Lua - Error Handling
- Lua - Debugging
- Lua - Garbage Collection
- Lua - Object Oriented
- Lua - Web Programming
- Lua - Database Access
- Lua - Game Programing
- Lua Useful Resources
- Lua - Quick Guide
- Lua - Useful Resources
- Lua - Discussion
Lua - Tables as Objects
Lua supports Object Oriented Programming by the concept of Table and first class functions. An object is having a state and functions to modify the state. In similar fashion, table can have state and function. But two tables with same values are different objects. Using metatables, we can create table which can act as a class template.
Tables, like objects, have a life cycle that is independent of who created them or where they were created.
Example - Define an Object as a Table
Consider a case of Rectangle Object. Let Rectangle has length, breadth as its state and a function area to get the computed area.
main.lua
-- create a Rectangle class Rectangle = {length = 10, breadth = 5} -- compute area of Rectangle function Rectangle.area() local area = Rectangle.length * Rectangle.breadth return area end -- create rectangle object r1 = Rectangle -- compute and print area of Rectangle object print(r1.area()) -- modify length r1.length = 20 -- compute and print updated area of Rectangle object print(r1.area())
Output
When the above code is built and executed, it produces the following result −
50 100
Example - Using global object to access the same Table
Problem with above code is that in area() function, we're using Rectangle as a global object. If Rectangle is set as nil, then code will fail.
main.lua
-- create a Rectangle class Rectangle = {length = 10, breadth = 5} -- compute area of Rectangle function Rectangle.area() local area = Rectangle.length * Rectangle.breadth return area end -- create rectangle object r1 = Rectangle -- compute and print area of Rectangle object print(r1.area()) -- set Rectangle as nil Rectangle = nil -- compute and print area of Rectangle object print(r1.area())
Output
When the above code is built and executed, it produces the following result −
50 lua: main.lua:6: attempt to index a nil value (global 'Rectangle') stack traceback: main.lua:6: in field 'area' main.lua:20: in main chunk [C]: in ?
Example - Using self object to access the same Table
Now to resolve this dependency, we can use self keyword to represent the current object.
main.lua
-- create a Rectangle class Rectangle = {length = 10, breadth = 5} -- compute area of Rectangle function Rectangle.area(self) local area = self.length * self.breadth return area end -- create rectangle object r1 = Rectangle -- compute and print area of Rectangle object print(r1.area(r1)) -- set Rectangle as nil Rectangle = nil -- compute and print area of Rectangle object print(r1.area(r1))
Output
When the above code is built and executed, it produces the following result −
50 50
Example - Using function within same Table
Let's rewrite the above example, to include the function area within Rectangle table.
main.lua
-- create a Rectangle class Rectangle = { length = 10, breadth = 5, -- compute area of Rectangle area = function (self) local area = self.length * self.breadth return area end } -- create rectangle object r1 = Rectangle -- compute and print area of Rectangle object print(r1.area(r1)) -- create another rectangle object r2 = Rectangle -- set new length, keep breadth same r2.length = 20 -- compute and print area of Rectangle object print(r2.area(r2))
Output
When the above code is built and executed, it produces the following result −
50 100
Example - Using function without passing same object
Let's rewrite the above example, to use : notation. Lua provides a special notation to access function of an object by passing self as argument internally. So we're not required to pass same object while calling the function.
main.lua
-- create a Rectangle class Rectangle = { length = 10, breadth = 5, -- compute area of Rectangle area = function (self) local area = self.length * self.breadth return area end } -- create rectangle object r1 = Rectangle -- compute and print area of Rectangle object print(r1:area()) -- create another rectangle object r2 = Rectangle -- set new length, keep breadth same r2.length = 20 -- compute and print area of Rectangle object print(r2:area())
Output
When the above code is built and executed, it produces the following result −
50 100