Lua is a powerful, efficient, lightweight, embeddable scripting language. One of its lesser-known but incredibly useful features is pattern matching. Pattern matching in Lua is similar to regular expressions in other programming languages but with a simpler and more straightforward syntax.

In this article, we'll explore the basics of Lua pattern matching and how to use it effectively.

Patterns in Lua are a way to describe the structure of strings. They are used in string manipulation functions such as string.match, string.find, string.gmatch, and string.gsub. Patterns are a type of regular expression but are much simpler and less powerful than the full regular expressions you might be used to.

Here are some of the basic pattern elements:

• Character Classes:
  • . : Matches any single character except a newline.
  • %a : Matches any letter (a-z, A-Z).
  • %c : Matches any control character.
  • %d : Matches any digit (0-9).
  • %l : Matches any lowercase letter.
  • %u : Matches any uppercase letter.
  • %p : Matches any punctuation character.
  • %s : Matches any space character.
  • %w : Matches any alphanumeric character.
  • %x : Matches any hexadecimal digit.

• Modifiers:
  • + : Matches one or more repetitions of the preceding character or class.
  • * : Matches zero or more repetitions of the preceding character or class.
  • - : Matches zero or more repetitions (non-greedy) of the preceding character or class.
  • ? : Matches zero or one occurrence of the preceding character or class.

• Anchors:
  • ^ : Anchors the pattern to the start of the string.
  • $ : Anchors the pattern to the end of the string.

• Escapes:
  • % : Used to escape a character that has a special meaning in patterns.

The string.match function is used to find a substring that matches a given pattern. It returns the first match found.

local s = "Hello, Lua!"
local match = string.match(s, "%a+")
print(match)  -- Output: Hello
 

The string.find function is similar to string.match but returns the start and end indices of the match.

local s = "Hello, Lua!"
local start_idx, end_idx = string.find(s, "Lua")
print(start_idx, end_idx)  -- Output: 8 10
 

The string.gmatch function is used to iterate over all matches in a string.

local s = "one, two, three"
for word in string.gmatch(s, "%a+") do
  print(word)
end
-- Output:
-- one
-- two
-- three
 

The string.gsub function is used to replace occurrences of a pattern with a replacement string.

local s = "Hello, Lua!"
local result = string.gsub(s, "Lua", "World")
print(result)  -- Output: Hello, World!
 

Let's look at a few practical examples to solidify our understanding.

local text = "Today's date is 2024-06-13 and tomorrow's date is 2024-06-14."
for date in string.gmatch(text, "%d%d%d%d%-%d%d%-%d%d") do
  print(date)
end
-- Output:
-- 2024-06-13
-- 2024-06-14
 

local email = "example@example.com"
local pattern = "^[%w._%+-]+@[%w.-]+%.%a%a+$"
if string.match(email, pattern) then
  print("Valid email address")
else
  print("Invalid email address")
end
 

Lua's pattern matching is a powerful tool for string manipulation. While not as powerful as full regular expressions, it is simpler and often sufficient for many common tasks. By understanding the basic pattern elements and how to use the pattern matching functions, you can effectively handle a wide range of string processing tasks in Lua.

Experiment with different patterns and functions to get a feel for how Lua pattern matching works. Happy coding!