Best Practices in Lua

Intermediate ~25 min read

Writing clean, efficient, and maintainable code is essential for professional development. In this lesson, you'll learn Lua best practices covering code style, naming conventions, performance optimization, security, and professional patterns. Let's explore how to write excellent Lua code!

Code Style and Formatting

Indentation and Spacing

-- Good: Consistent 4-space indentation
function calculateTotal(items)
    local total = 0
    for i, item in ipairs(items) do
        if item.price > 0 then
            total = total + item.price
        end
    end
    return total
end

-- Bad: Inconsistent indentation
function calculateTotal(items)
local total = 0
  for i, item in ipairs(items) do
      if item.price > 0 then
    total = total + item.price
      end
  end
return total
end

Line Length

-- Good: Keep lines under 80-100 characters
local function createUser(name, email, age, address, phone)
    return {
        name = name,
        email = email,
        age = age,
        address = address,
        phone = phone
    }
end

-- Bad: Very long lines
local function createUser(name, email, age, address, phone) return {name = name, email = email, age = age, address = address, phone = phone} end

-- Lua Best Practices: Style Guide

-- 1. Indentation: Use 2 or 4 spaces (be consistent)
print("=== Indentation ===")

-- Good (2 spaces)
local function example1()
  if true then
    print("Hello")
  end
end

-- Good (4 spaces)
local function example2()
    if true then
        print("Hello")
    end
end

-- Bad (mixed)
local function bad()
  if true then
      print("Inconsistent")
    end
end

-- 2. Naming conventions
print("\n=== Naming Conventions ===")

-- Variables and functions: camelCase or snake_case
local userName = "Alice"
local user_name = "Alice"  -- Both acceptable, be consistent

-- Constants: UPPER_CASE
local MAX_SIZE = 100
local DEFAULT_TIMEOUT = 30

-- Classes/Modules: PascalCase
local MyClass = {}
local StringUtils = {}

-- Private functions: prefix with underscore
local function _privateHelper()
    return "private"
end

-- Boolean variables: use is/has prefix
local isActive = true
local hasPermission = false

-- 3. Spacing
print("\n=== Spacing ===")

-- Good spacing
local x = 10 + 20
local result = calculate(a, b, c)
local data = {name = "Alice", age = 25}

-- Bad spacing
local y=10+20
local result2=calculate(a,b,c)
local data2={name="Alice",age=25}

-- 4. Line length
print("\n=== Line Length ===")

-- Keep lines under 80-100 characters
-- Break long lines

-- Bad
local veryLongFunctionName = function(firstParameter, secondParameter, thirdParameter, fourthParameter)
    return firstParameter + secondParameter + thirdParameter + fourthParameter
end

-- Good
local veryLongFunctionName = function(
    firstParameter,
    secondParameter,
    thirdParameter,
    fourthParameter
)
    return firstParameter + secondParameter +
           thirdParameter + fourthParameter
end

-- 5. Comments
print("\n=== Comments ===")

-- Single-line comments for brief explanations
local count = 0  -- Initialize counter

--[[
Multi-line comments for longer explanations
or documentation blocks
]]

--- Documentation style comment
-- @param x number The input value
-- @return number The squared value
local function square(x)
    return x * x
end

-- 6. Function declarations
print("\n=== Function Declarations ===")

-- Prefer local functions
local function goodFunction()
    return "local"
end

-- Avoid global functions
function badFunction()  -- Creates global
    return "global"
end

-- Method syntax for tables
local MyObject = {}

function MyObject:method()  -- Good for methods
    return self.value
end

function MyObject.staticMethod()  -- Good for static
    return "static"
end

-- 7. Table constructors
print("\n=== Table Constructors ===")

-- Good: One line for simple tables
local point = {x = 10, y = 20}

-- Good: Multiple lines for complex tables
local person = {
    name = "Alice",
    age = 25,
    address = {
        city = "New York",
        zip = "10001"
    }
}

-- Good: Trailing comma allowed
local colors = {
    "red",
    "green",
    "blue",  -- Trailing comma OK
}

-- 8. String quotes
print("\n=== String Quotes ===")

-- Use double quotes for strings
local message = "Hello, World!"

-- Use single quotes for strings with double quotes inside
local html = '<div class="container">Content</div>'

-- Use [[]] for multi-line strings
local multiline = [[
This is a
multi-line
string
]]

-- 9. Conditional statements
print("\n=== Conditionals ===")

-- Good: Clear and readable
if condition then
    doSomething()
elseif otherCondition then
    doSomethingElse()
else
    doDefault()
end

-- Good: Simple one-liners
if x > 0 then return x end

-- Avoid: Ternary-style (Lua doesn't have ternary)
-- Use: and/or pattern carefully
local value = condition and trueValue or falseValue

-- 10. Loops
print("\n=== Loops ===")

-- Good: Use appropriate loop type
for i = 1, 10 do
    print(i)
end

for i, v in ipairs(array) do
    print(i, v)
end

for k, v in pairs(table) do
    print(k, v)
end

while condition do
    doSomething()
end

-- 11. Error handling
print("\n=== Error Handling ===")

-- Good: Return nil, error for recoverable errors
local function divide(a, b)
    if b == 0 then
        return nil, "Division by zero"
    end
    return a / b
end

-- Good: Use error() for unrecoverable errors
local function mustSucceed(value)
    if not value then
        error("Value is required", 2)
    end
    return value
end

-- Good: Use pcall for risky operations
local ok, result = pcall(riskyFunction)
if not ok then
    print("Error:", result)
end

-- 12. Module structure
print("\n=== Module Structure ===")

-- Good module pattern
local M = {}

-- Constants at top
M.VERSION = "1.0.0"

-- Private functions
local function helper()
    return "private"
end

-- Public functions
function M.publicFunction()
    return helper()
end

-- Return module
-- return M

-- 13. Avoid magic numbers
print("\n=== Magic Numbers ===")

-- Bad
if user.age > 18 then
    -- ...
end

-- Good
local ADULT_AGE = 18
if user.age > ADULT_AGE then
    -- ...
end

-- 14. Use descriptive names
print("\n=== Descriptive Names ===")

-- Bad
local function f(x, y)
    return x + y
end

-- Good
local function calculateSum(firstNumber, secondNumber)
    return firstNumber + secondNumber
end

-- 15. Consistent style
print("\n=== Consistency ===")

-- Pick a style and stick to it throughout your project
-- Examples:
-- - camelCase vs snake_case
-- - 2 spaces vs 4 spaces
-- - Single quotes vs double quotes
-- - Function declaration style

-- Document your style guide and follow it!

Output

Click Run to execute your code

Naming Conventions

Variables and Functions

-- Good: Descriptive, lowercase with underscores
local user_count = 0
local is_active = true
local max_retry_attempts = 3

function calculate_total_price(items)
    -- Implementation
end

-- Bad: Unclear, inconsistent
local uc = 0
local IsActive = true
local MAXRETRY = 3

function calcTP(i)
    -- Implementation
end

Constants

-- Good: UPPERCASE with underscores
local MAX_CONNECTIONS = 100
local DEFAULT_TIMEOUT = 30
local API_VERSION = "1.0"

-- Bad: Lowercase like variables
local maxConnections = 100
local defaulttimeout = 30

Classes and Modules

-- Good: PascalCase for classes
local UserManager = {}
local DatabaseConnection = {}
local HttpClient = {}

-- Good: lowercase for modules
local string_utils = require("string_utils")
local math_helpers = require("math_helpers")

Always Use Local Variables

-- Good: Local variables
local function processData(data)
    local result = {}
    local count = 0
    
    for i, item in ipairs(data) do
        count = count + 1
        table.insert(result, item)
    end
    
    return result, count
end

-- Bad: Global variables (pollutes global namespace)
function processData(data)
    result = {}  -- Global!
    count = 0    -- Global!
    
    for i, item in ipairs(data) do
        count = count + 1
        table.insert(result, item)
    end
    
    return result, count
end

Warning: Global variables can cause hard-to-find bugs and naming conflicts. Always use local unless you specifically need a global.

Performance Best Practices

Cache Table Lookups

-- Good: Cache frequently accessed values
local function processItems(items)
    local insert = table.insert  -- Cache table.insert
    local result = {}
    
    for i = 1, #items do
        insert(result, items[i] * 2)
    end
    
    return result
end

-- Less efficient: Repeated table lookups
local function processItems(items)
    local result = {}
    
    for i = 1, #items do
        table.insert(result, items[i] * 2)  -- Looks up table.insert every time
    end
    
    return result
end

Use table.concat() for String Building

-- Good: Use table.concat()
local function buildString(parts)
    return table.concat(parts, ", ")
end

-- Bad: String concatenation in loop
local function buildString(parts)
    local result = ""
    for i, part in ipairs(parts) do
        result = result .. part .. ", "  -- Creates new string each iteration
    end
    return result
end

Reuse Tables

-- Good: Reuse table
local temp = {}
for i = 1, 1000 do
    -- Clear and reuse
    for k in pairs(temp) do
        temp[k] = nil
    end
    -- Use temp
end

-- Less efficient: Create new table each iteration
for i = 1, 1000 do
    local temp = {}  -- New allocation each time
    -- Use temp
end

-- Lua Best Practices: Performance

-- 1. Use local variables (faster access)
print("=== Local vs Global ===")

-- Slow (global access)
function slowFunction()
    for i = 1, 1000000 do
        math.sqrt(i)  -- Global lookup every time
    end
end

-- Fast (local access)
local function fastFunction()
    local sqrt = math.sqrt  -- Cache in local
    for i = 1, 1000000 do
        sqrt(i)
    end
end

-- 2. Pre-allocate tables when size is known
print("\n=== Table Pre-allocation ===")

-- Slow
local function slowTableCreation()
    local t = {}
    for i = 1, 10000 do
        t[i] = i
    end
    return t
end

-- Faster (though Lua doesn't have explicit pre-allocation)
local function fasterTableCreation()
    local t = {}
    for i = 1, 10000 do
        t[i] = i
    end
    return t
end

-- 3. Use table.concat for string building
print("\n=== String Concatenation ===")

-- Slow (creates many intermediate strings)
local function slowConcat()
    local s = ""
    for i = 1, 1000 do
        s = s .. tostring(i)
    end
    return s
end

-- Fast (uses table.concat)
local function fastConcat()
    local t = {}
    for i = 1, 1000 do
        t[i] = tostring(i)
    end
    return table.concat(t)
end

-- 4. Avoid table.insert in loops when possible
print("\n=== Array Building ===")

-- Slower
local function withInsert()
    local t = {}
    for i = 1, 10000 do
        table.insert(t, i)
    end
    return t
end

-- Faster
local function withDirectAssignment()
    local t = {}
    for i = 1, 10000 do
        t[i] = i
    end
    return t
end

-- 5. Cache table lookups
print("\n=== Cache Lookups ===")

-- Slow
local function slowLookup(data)
    for i = 1, #data do
        print(data.config.settings.timeout)  -- Lookup chain every time
    end
end

-- Fast
local function fastLookup(data)
    local timeout = data.config.settings.timeout  -- Cache
    for i = 1, #data do
        print(timeout)
    end
end

-- 6. Use ipairs for sequential arrays
print("\n=== Array Iteration ===")

local array = {10, 20, 30, 40, 50}

-- Slower (pairs checks all keys)
for k, v in pairs(array) do
    -- process
end

-- Faster (ipairs optimized for arrays)
for i, v in ipairs(array) do
    -- process
end

-- Fastest (numeric for)
for i = 1, #array do
    local v = array[i]
    -- process
end

-- 7. Avoid creating functions in loops
print("\n=== Function Creation ===")

-- Slow (creates new function each iteration)
local function slowFunctionCreation()
    local callbacks = {}
    for i = 1, 1000 do
        callbacks[i] = function() return i end
    end
    return callbacks
end

-- Better (reuse function)
local function betterFunctionCreation()
    local function makeCallback(value)
        return function() return value end
    end
    
    local callbacks = {}
    for i = 1, 1000 do
        callbacks[i] = makeCallback(i)
    end
    return callbacks
end

-- 8. Use local functions
print("\n=== Local Functions ===")

-- Slower (global function)
function globalFunc(x)
    return x * 2
end

-- Faster (local function)
local function localFunc(x)
    return x * 2
end

-- 9. Minimize table creations
print("\n=== Reuse Tables ===")

-- Slow (creates new table each time)
local function slowTableReuse()
    for i = 1, 1000 do
        local temp = {x = i, y = i * 2}
        -- process temp
    end
end

-- Faster (reuse table)
local function fastTableReuse()
    local temp = {}
    for i = 1, 1000 do
        temp.x = i
        temp.y = i * 2
        -- process temp
    end
end

-- 10. Use math functions efficiently
print("\n=== Math Operations ===")

-- Slower
local function slowMath(x)
    return x ^ 2  -- Power operator
end

-- Faster
local function fastMath(x)
    return x * x  -- Direct multiplication
end

-- 11. Avoid unnecessary type conversions
print("\n=== Type Conversions ===")

-- Slower
local function slowConversion(n)
    return tostring(n) .. ""
end

-- Faster
local function fastConversion(n)
    return tostring(n)
end

-- 12. Use weak tables for caches
print("\n=== Weak Tables ===")

local cache = {}
setmetatable(cache, {__mode = "v"})  -- Values are weak

local function getCachedValue(key)
    if not cache[key] then
        cache[key] = expensiveComputation(key)
    end
    return cache[key]
end

function expensiveComputation(key)
    return key * 2  -- Simulated expensive operation
end

-- 13. Batch operations
print("\n=== Batch Operations ===")

-- Slower (many small operations)
local function manySmallOps()
    local sum = 0
    for i = 1, 1000 do
        sum = sum + i
    end
    return sum
end

-- Same speed, but principle applies to I/O
-- Batch file writes, database operations, etc.

-- 14. Profile before optimizing
print("\n=== Profiling ===")

local function profile(func, name)
    local start = os.clock()
    func()
    local elapsed = os.clock() - start
    print(string.format("%s: %.6f seconds", name, elapsed))
end

profile(slowConcat, "Slow concat")
profile(fastConcat, "Fast concat")

-- 15. Memory management
print("\n=== Memory Management ===")

-- Force garbage collection when needed
collectgarbage("collect")

-- Check memory usage
local memBefore = collectgarbage("count")
-- ... do work ...
local memAfter = collectgarbage("count")
print(string.format("Memory used: %.2f KB", memAfter - memBefore))

-- 16. Avoid global variables
print("\n=== Avoid Globals ===")

-- Slow
_G.counter = 0
function incrementGlobal()
    _G.counter = _G.counter + 1
end

-- Fast
local counter = 0
local function incrementLocal()
    counter = counter + 1
end

Output

Click Run to execute your code

Error Handling Best Practices

Validate Input Early

-- Good: Validate at function entry
local function divide(a, b)
    assert(type(a) == "number", "First argument must be a number")
    assert(type(b) == "number", "Second argument must be a number")
    assert(b ~= 0, "Cannot divide by zero")
    
    return a / b
end

-- Bad: No validation
local function divide(a, b)
    return a / b  -- May cause runtime errors
end

Return nil, error for Expected Failures

-- Good: Return nil, error
local function readConfig(filename)
    local file, err = io.open(filename, "r")
    if not file then
        return nil, "Failed to open config: " .. err
    end
    
    local content = file:read("*all")
    file:close()
    
    return content
end

-- Usage
local config, err = readConfig("config.txt")
if not config then
    print("Error:", err)
    return
end

Code Organization

Keep Functions Small

-- Good: Small, focused functions
local function validateEmail(email)
    return email:match("^[%w.]+@[%w.]+%.%w+$") ~= nil
end

local function validateAge(age)
    return type(age) == "number" and age >= 0 and age <= 150
end

local function createUser(name, email, age)
    if not validateEmail(email) then
        return nil, "Invalid email"
    end
    if not validateAge(age) then
        return nil, "Invalid age"
    end
    
    return {name = name, email = email, age = age}
end

-- Bad: One large function
local function createUser(name, email, age)
    if not email:match("^[%w.]+@[%w.]+%.%w+$") then
        return nil, "Invalid email"
    end
    if type(age) ~= "number" or age < 0 or age > 150 then
        return nil, "Invalid age"
    end
    -- More validation...
    -- More logic...
    -- Gets hard to read and maintain
end

Single Responsibility Principle

-- Good: Each function has one responsibility
local function loadData(filename)
    -- Only loads data
    local file = io.open(filename, "r")
    local content = file:read("*all")
    file:close()
    return content
end

local function parseData(content)
    -- Only parses data
    local data = {}
    for line in content:gmatch("[^\n]+") do
        table.insert(data, line)
    end
    return data
end

local function processData(data)
    -- Only processes data
    local result = {}
    for i, item in ipairs(data) do
        table.insert(result, item:upper())
    end
    return result
end

-- Bad: One function does everything
local function loadAndProcessData(filename)
    -- Loads, parses, and processes - too many responsibilities
end

Documentation

--[[
    Calculates the total price of items in a shopping cart
    
    @param items table Array of item objects with 'price' and 'quantity' fields
    @param discount number Optional discount percentage (0-100)
    @return number Total price after discount
    @return number Amount saved from discount
]]
local function calculateTotal(items, discount)
    discount = discount or 0
    
    local subtotal = 0
    for i, item in ipairs(items) do
        subtotal = subtotal + (item.price * item.quantity)
    end
    
    local discountAmount = subtotal * (discount / 100)
    local total = subtotal - discountAmount
    
    return total, discountAmount
end

-- Lua Best Practices: Code Organization

-- 1. Always use local variables
print("=== Use Local Variables ===")

-- Bad
globalVar = 10  -- Pollutes global namespace

-- Good
local localVar = 10  -- Scoped properly

-- 2. Declare variables at the top
print("\n=== Variable Declaration ===")

local function processData(data)
    -- Declare all locals at the top
    local result
    local temp
    local count = 0
    
    -- Then use them
    for i, v in ipairs(data) do
        count = count + 1
    end
    
    return count
end

-- 3. Use meaningful names
print("\n=== Meaningful Names ===")

-- Bad
local function f(x, y)
    return x + y
end

-- Good
local function calculateSum(firstNumber, secondNumber)
    return firstNumber + secondNumber
end

-- 4. Module structure
print("\n=== Module Structure ===")

-- Good module pattern
local MyModule = {}

-- Private functions
local function privateHelper()
    return "private"
end

-- Public functions
function MyModule.publicFunction()
    return privateHelper() .. " to public"
end

-- Module metadata
MyModule._VERSION = "1.0.0"
MyModule._DESCRIPTION = "Example module"

-- Return module
-- return MyModule

-- 5. Error handling
print("\n=== Error Handling ===")

-- Bad
local function divide(a, b)
    return a / b  -- No error checking
end

-- Good
local function safeDivide(a, b)
    if type(a) ~= "number" or type(b) ~= "number" then
        return nil, "Arguments must be numbers"
    end
    if b == 0 then
        return nil, "Division by zero"
    end
    return a / b
end

-- 6. Function organization
print("\n=== Function Organization ===")

-- Group related functions
local StringUtils = {}

function StringUtils.trim(s)
    return s:match("^%s*(.-)%s*$")
end

function StringUtils.split(s, delimiter)
    local result = {}
    for match in (s .. delimiter):gmatch("(.-)" .. delimiter) do
        table.insert(result, match)
    end
    return result
end

function StringUtils.capitalize(s)
    return string.upper(string.sub(s, 1, 1)) .. string.sub(s, 2)
end

-- 7. Constants
print("\n=== Constants ===")

-- Use uppercase for constants
local MAX_SIZE = 100
local DEFAULT_TIMEOUT = 30
local API_VERSION = "v1"

local Config = {
    MAX_RETRIES = 3,
    TIMEOUT = 5000,
    DEBUG = false
}

-- 8. Table constructors
print("\n=== Table Constructors ===")

-- Bad
local person = {}
person.name = "Alice"
person.age = 25

-- Good
local person = {
    name = "Alice",
    age = 25
}

-- 9. Comments
print("\n=== Comments ===")

-- Single-line comment for brief explanations

--[[
Multi-line comment for longer explanations
or documentation blocks
]]

--- Documentation comment
-- @param x number The first number
-- @param y number The second number
-- @return number The sum
local function add(x, y)
    return x + y
end

-- 10. Code formatting
print("\n=== Code Formatting ===")

-- Consistent indentation (2 or 4 spaces)
local function example()
    if true then
        local x = 10
        if x > 5 then
            print("Greater than 5")
        end
    end
end

-- Spaces around operators
local result = 10 + 20  -- Good
local bad = 10+20  -- Bad

-- 11. Return early pattern
print("\n=== Return Early ===")

-- Bad
local function processUser(user)
    if user then
        if user.active then
            if user.age >= 18 then
                return "Valid"
            end
        end
    end
    return "Invalid"
end

-- Good
local function processUserBetter(user)
    if not user then return "Invalid" end
    if not user.active then return "Invalid" end
    if user.age < 18 then return "Invalid" end
    return "Valid"
end

-- 12. Avoid deep nesting
print("\n=== Avoid Deep Nesting ===")

-- Bad
local function deepNesting(data)
    if data then
        if data.user then
            if data.user.profile then
                return data.user.profile.name
            end
        end
    end
    return nil
end

-- Good
local function shallowNesting(data)
    if not data then return nil end
    if not data.user then return nil end
    if not data.user.profile then return nil end
    return data.user.profile.name
end

-- 13. Use table.insert for arrays
print("\n=== Array Operations ===")

-- Good
local items = {}
table.insert(items, "first")
table.insert(items, "second")

-- Also good for specific index
table.insert(items, 1, "at beginning")

-- 14. Consistent naming conventions
print("\n=== Naming Conventions ===")

-- Variables and functions: camelCase or snake_case
local userName = "Alice"
local user_name = "Alice"

-- Constants: UPPER_CASE
local MAX_CONNECTIONS = 100

-- Classes/Modules: PascalCase
local MyClass = {}

-- Private: prefix with underscore
local function _privateFunction()
    return "private"
end

-- 15. File organization
print("\n=== File Organization ===")

--[[
Recommended file structure:

1. Module declaration
2. Dependencies (require statements)
3. Constants
4. Private functions
5. Public functions
6. Return module

Example:

local MyModule = {}

-- Dependencies
local utils = require("utils")

-- Constants
local VERSION = "1.0.0"

-- Private
local function helper()
end

-- Public
function MyModule.doSomething()
end

return MyModule
]]

Output

Click Run to execute your code

Security Best Practices

Security Tips:

Validate all input: Never trust user input
Avoid load() and loadstring(): Can execute arbitrary code
Sanitize file paths: Prevent directory traversal
Use pcall() for untrusted code: Contain errors
Don't expose debug library: In production

Best Practices Checklist

✓ Code Style:

Consistent indentation (4 spaces)
Lines under 80-100 characters
Meaningful variable names
Proper spacing around operators

✓ Variables:

Always use local
Descriptive names
UPPERCASE for constants

✓ Functions:

Keep functions small and focused
Validate input early
Return nil, error for failures
Document complex functions

✓ Performance:

Cache table lookups
Use table.concat() for strings
Reuse tables when possible
Profile before optimizing

✓ Organization:

One module, one responsibility
Group related functions
Use meaningful file names
Keep modules focused

Practice Exercise

Review and improve this code:

-- Exercise: Best Practices
-- TODO: Complete the following exercises

-- 1. Refactor this code to use local variables
x = 10
y = 20
function add()
    return x + y
end

-- Refactored version:
-- local x = 10
-- local y = 20
-- local function add()
--     return x + y
-- end

-- 2. Improve this string concatenation
local function buildString()
    local s = ""
    for i = 1, 1000 do
        s = s .. tostring(i) .. ","
    end
    return s
end

-- Improved version using table.concat:
-- local function buildStringBetter()
--     -- your code here
-- end

-- 3. Fix the naming conventions
local function f(x, y)
    local r = x + y
    return r
end

-- Fixed version:
-- local function calculateSum(firstNumber, secondNumber)
--     -- your code here
-- end

-- 4. Improve error handling
local function divide(a, b)
    return a / b
end

-- Improved version:
-- local function safeDivide(a, b)
--     -- your code here
--     -- check for errors and return nil, error
-- end

-- 5. Optimize this table lookup
local config = {
    settings = {
        timeout = 30,
        retries = 3
    }
}

local function processItems(items)
    for i = 1, #items do
        print(config.settings.timeout)
    end
end

-- Optimized version:
-- local function processItemsOptimized(items)
--     -- your code here
--     -- cache the timeout value
-- end

-- 6. Refactor to avoid deep nesting
local function checkUser(data)
    if data then
        if data.user then
            if data.user.profile then
                if data.user.profile.active then
                    return true
                end
            end
        end
    end
    return false
end

-- Refactored version:
-- local function checkUserBetter(data)
--     -- your code here
--     -- use early returns
-- end

-- 7. Create a well-structured module
-- TODO: Create a module with:
-- - Module table
-- - Constants
-- - Private functions
-- - Public functions
-- - Proper return statement

local MyModule = {}

-- your code here

-- return MyModule

-- 8. Add proper comments and documentation
local function process(x, y)
    return x * y + x / y
end

-- Documented version:
-- --- Processes two numbers with a complex calculation
-- -- @param x number The first number
-- -- @param y number The second number
-- -- @return number The calculated result
-- local function process(x, y)
--     -- your code here
-- end

-- 9. Improve this code's performance
local function slowFunction()
    for i = 1, 10000 do
        local temp = {x = i, y = i * 2}
        -- process temp
    end
end

-- Optimized version:
-- local function fastFunction()
--     -- your code here
--     -- reuse the temp table
-- end

-- 10. Fix the style issues
local function badStyle(a,b,c)
local result=a+b+c
return result
end

-- Fixed version:
-- local function goodStyle(a, b, c)
--     -- your code here
--     -- proper spacing and formatting
-- end

Output

Click Run to execute your code

Summary

In this lesson, you learned:

Code style and formatting guidelines
Naming conventions for variables, functions, and modules
Always using local variables
Performance optimization techniques
Error handling best practices
Code organization principles
Documentation standards
Security considerations

What's Next?

Congratulations on completing Module 6! You now know how to write professional, maintainable Lua code. In the final module, we'll explore advanced topics including coroutines, file I/O, and performance optimization. Let's finish strong! 🚀

Previous Debugging

Next Coroutines

Code Style and Formatting

Indentation and Spacing

Line Length

Naming Conventions

Variables and Functions

Constants

Classes and Modules

Always Use Local Variables

Performance Best Practices

Cache Table Lookups

Use table.concat() for String Building

Reuse Tables

Error Handling Best Practices

Validate Input Early

Return nil, error for Expected Failures

Code Organization

Keep Functions Small

Single Responsibility Principle

Documentation

Security Best Practices

Best Practices Checklist

Practice Exercise

Summary

What's Next?

Enjoying these tutorials?