Error Handling in Lua

Human always make mistakes. We are in no exception. One of the essential aspect of programming is Error handling. Lua provides several mechanisms to handle errors gracefully. Such that you can create more reliable and maintainable code. In this tutorial, I will share with you the primary techniques for error handling in Lua. You will learn something like pcall, xpcall, and the assert function.

Using “pcall” for Error Handling

The pcall is called protected call. It is a function allows you to call a function in protected mode. Just imagine if you made a mistake, the function throws an error and pcall catches it and returns a status code along with the error message. Let’s take a look of the basic syntax:

local status, result = pcall(function)

In the above line of code, status is a boolean indicating whether the function call was successful. And then the result contains the return value of the function if successful. Or, it contain the error message if an something went wrong. Let’s see below example to demonstrate how it’s work:

Lua error handling example

local function divide(a, b)
    if b == 0 then
        error("Division by zero!")
    end
    return a / b
end

local status, result = pcall(divide, 10, 0)

if status then
    print("Result: " .. result)
else
    print("Error: " .. result)
end

You know math, when the denominator is ZERO will cause error. The function pcall catches the “Division by zero!” error, and the error message is printed out.

Error Handling with xpcall

Now let’s move a step ahead. The function xpcall extends the functionality of pcall by allowing you to specify an error handler. More specifically, this handler can provide more detailed error information or perform additional actions when an error occurs. The syntax is quite similar to pcall

local status, result = xpcall(function, errorHandler)

The errorHandler is a function that gets called if an error occurs. Let’s see it in action.

Lua xpcall example

local function divide(a, b)
    if b == 0 then
        error("Again, division by zero is not allowed!")
    end
    return a / b
end

local function errorHandler(err)
    return "Error handled: " .. err
end

local status, result = xpcall(divide, errorHandler, 850, 0)

if status then
    print("Result: " .. result)
else
    print(result)  -- Output: Error handled: Division by zero!
end

So you can see in this example, the errorHandler function customizes the error message. You can change whatever wording you want.

Using assert for Simple Error Checking in Lua

Sometime, we may just need to check if there is an error without much details. Then you can use the assert function. It checks a condition and throws an error if the condition is false. It is useful for simple validation checks. The syntax is pretty simple and straight forward.

assert(condition, message)

The first parameter condition is the expression to check. And the second parameter message is the error message to throw if the condition is false. Below is an example to demonstrate how to use assert() function.

Check error with assert()

local function divide(a, b)
    assert(b ~= 0, "Division by zero!")
    return a / b
end

local result = divide(999, 0)  -- This will throw an error: Division by zero!
print("The Result: " .. result)

In this example, assert throws an error with the message “Division by zero!” if the condition b ~= 0 is false.

Lua Custom Error Handling with error

Other than the ways mention above, you can use the error function to throw custom errors in your code. In this way, you can provide specific error messages and control when errors occur. Let’s look at the syntax:

error(message, level)

Straightforwardly, message is the error message. And level specifies the stack level at which the error originated (this is optional).

Lua Custom error Example

local function sqrt(number)
    if number < 0 then
        error("Cannot calculate the square root of a negative number!", 2)
    end
    return math.sqrt(number)
end

local status, result = pcall(sqrt, -9)

if status then
    print("Result: " .. result)
else
    print("Error: " .. result)
end

The sqrt function calculates the square root of a number. If the number is negative, it raises an error using the error() function. On the other hand, pcall is used to call the sqrt function in protected mode. This catches any errors and prevents the script from crashing.

So if the status is true, it prints the result or otherwise it prints the error message.

Wrap Up

Remember effective error handling is so important. It help you save lots of time for debugging around the code. By using the mentioned pcall, xpcall, assert, and error, you can handle errors gracefully, provide meaningful error messages, and ensure your code runs smoothly even in unexpected situations.