Lua Requires Chilkat v11.1.0+

Regular Expression Replace Capture Groups

See more Regular Expressions Examples

Demonstrates replacing capture groups for a regular expression.

Note: Chilkat uses PCRE2. See PCRE2 Regular Expressions
Also see: PCRE2 Performance

Lua

local chilkat = require("chilkat")

local subject = "John Anders, +_+_+ Mary Robins $$$$"
local pattern = "(?<first>\\w+)\\s+(?<last>\\w+)"

local sb = chilkat.StringBuilder.new()
sb:append(subject)

local json = chilkat.JsonObject.new()
json.emit_compact = false

local timeoutMs = 2000
local numMatches = sb:regex_match(pattern, json, timeoutMs)
if numMatches < 0 then
    -- Probably an error in the regular expression.
    -- Suggestion: Use AI to help create and/or diagnose regular expressions.
    print(sb.last_error_text)
    return
end

-- Examine the matches:
print(json:emit())

-- There are 2 matches:

-- {
--   "named": {
--     "first": 1,
--     "last": 2
--   },
--   "match": [
--     {
--       "group": [
--         {
--           "cap": "John Anders",
--           "idx": 0,
--           "len": 11
--         },
--         {
--           "cap": "John",
--           "idx": 0,
--           "len": 4
--         },
--         {
--           "cap": "Anders",
--           "idx": 5,
--           "len": 6
--         }
--       ]
--     },
--     {
--       "group": [
--         {
--           "cap": "Mary Robins",
--           "idx": 19,
--           "len": 11
--         },
--         {
--           "cap": "Mary",
--           "idx": 19,
--           "len": 4
--         },
--         {
--           "cap": "Robins",
--           "idx": 24,
--           "len": 6
--         }
--       ]
--     }
--   ]
-- }

-- To replace capture groups, write code to examine each capture group within
-- each match, and provide a replacement string.
-- Then call RegexReplace.

-- For example, let's capitalize the first names, and add append "on" to the last name.
-- After doing replacements, we should get:  JOHN Anderson, +_+_+ MARY Robinson $$$$

local firstNameIdx = json:int_of("named.first")
local lastNameIdx = json:int_of("named.last")

local sbTemp = chilkat.StringBuilder.new()

local i = 0
numMatches = json:size_of_array("match")
while i < numMatches do
    json.i = i

    -- The replacement string for the first name will be all uppercase.
    json.j = firstNameIdx
    sbTemp:clear()
    json:string_of_sb("match[i].group[j].cap", sbTemp)
    sbTemp:to_uppercase()
    json:update_sb("match[i].group[j].rep", sbTemp)

    -- Append "on" to the last name.
    json.j = lastNameIdx
    sbTemp:clear()
    json:string_of_sb("match[i].group[j].cap", sbTemp)
    sbTemp:append("on")
    json:update_sb("match[i].group[j].rep", sbTemp)

    i = i + 1
end

-- The JSON now has replacement strings:
print(json:emit())

-- {
--   "named": {
--     "first": 1,
--     "last": 2
--   },
--   "match": [
--     {
--       "group": [
--         {
--           "cap": "John Anders",
--           "idx": 0,
--           "len": 11
--         },
--         {
--           "cap": "John",
--           "idx": 0,
--           "len": 4,
--           "rep": "JOHN"
--         },
--         {
--           "cap": "Anders",
--           "idx": 5,
--           "len": 6,
--           "rep": "Anderson"
--         }
--       ]
--     },
--     {
--       "group": [
--         {
--           "cap": "Mary Robins",
--           "idx": 19,
--           "len": 11
--         },
--         {
--           "cap": "Mary",
--           "idx": 19,
--           "len": 4,
--           "rep": "MARY"
--         },
--         {
--           "cap": "Robins",
--           "idx": 24,
--           "len": 6,
--           "rep": "Robinson"
--         }
--       ]
--     }
--   ]
-- }

-- Call RegexReplace to update the StringBuilder with the replacements.
local success = sb:regex_replace(json)
if not success then
    print(sb.last_error_text)
    return
end

print("Result after doing replacements:")
print(sb:get_as_string())

-- Result after doing replacements:
-- JOHN Anderson, +_+_+ MARY Robinson $$$$