RegexRef

// Using a regex literal
const regex1 = /hello\sworld/gi;

// Using the RegExp constructor
const regex2 = new RegExp('hello\\sworld', 'gi');

// Dynamic pattern from user input
const userInput = 'search term';
const regex3 = new RegExp(
  userInput.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'),
  'g'
);

JavaScript supports regex literals with /pattern/flags syntax and the RegExp constructor for dynamic patterns.

const pattern = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;

// test() returns boolean
console.log(pattern.test('user@example.com')); // true
console.log(pattern.test('invalid-email'));     // false

// match() returns match details or null
const result = 'user@example.com'.match(pattern);
if (result) {
  console.log(result[0]); // 'user@example.com'
}

Use test() for boolean checks and match() to get match details including captured groups.

const text = 'Prices: $9.99, $24.50, and $149.00';
const priceRegex = /\$\d+\.\d{2}/g;

// Using matchAll() - returns iterator of match objects
for (const match of text.matchAll(priceRegex)) {
  console.log(`Found: ${match[0]} at index ${match.index}`);
}

// Using match() with global flag - returns array of matches
const allMatches = text.match(priceRegex);
console.log(allMatches); // ['$9.99', '$24.50', '$149.00']

matchAll() provides detailed match objects with indices, while match() with the g flag returns a simple array of all matches.

const text = '2024-01-15';

// Simple replacement
const result1 = text.replace(/-(\d{2})-(\d{2})$/, '/$1/$2');
console.log(result1); // '2024/01/15'

// Using a replacement function
const result2 = 'hello world'.replace(
  /\b\w/g,
  (char) => char.toUpperCase()
);
console.log(result2); // 'Hello World'

// replaceAll() for global replacement
const result3 = 'a.b.c'.replaceAll('.', '-');
console.log(result3); // 'a-b-c'

replace() and replaceAll() support string patterns, regex patterns, and replacement functions for complex transformations.

const dateRegex = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
const match = '2024-01-15'.match(dateRegex);

if (match?.groups) {
  const { year, month, day } = match.groups;
  console.log(`Year: ${year}, Month: ${month}, Day: ${day}`);
  // Year: 2024, Month: 01, Day: 15
}

// Named groups in replace()
const reformatted = '2024-01-15'.replace(
  /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/,
  '$<month>/$<day>/$<year>'
);
console.log(reformatted); // '01/15/2024'

Named capture groups use (?<name>...) syntax and are accessible via match.groups object or $<name> in replacement strings.

import re

# Compile a pattern (recommended for reuse)
pattern = re.compile(r'hello\sworld', re.IGNORECASE)

# Use raw strings to avoid escaping backslashes
email_re = re.compile(
    r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
)

# Verbose mode for complex patterns
phone_re = re.compile(r'''
    (?:\+1[-.\ ]?)?     # optional country code
    \(?\d{3}\)?        # area code
    [-.\ ]?             # separator
    \d{3}[-.\ ]?\d{4}  # number
''', re.VERBOSE)

Python uses the re module with compiled patterns for performance. Raw strings (r"...") prevent backslash escaping issues.

import re

pattern = re.compile(r'^\d{4}-\d{2}-\d{2}$')

# search() finds first match anywhere in string
result = re.search(r'\d+', 'abc 123 def')
if result:
    print(result.group())  # '123'
    print(result.span())   # (4, 7)

# match() only matches at beginning of string
result = re.match(r'\d+', '123 abc')
print(bool(result))  # True

# fullmatch() requires entire string to match
result = re.fullmatch(r'\d+', '12345')
print(bool(result))  # True

search() finds matches anywhere, match() only at the start, and fullmatch() requires the entire string to match the pattern.

import re

text = 'Prices: $9.99, $24.50, and $149.00'

# findall() returns list of matched strings
prices = re.findall(r'\$\d+\.\d{2}', text)
print(prices)  # ['$9.99', '$24.50', '$149.00']

# finditer() returns iterator of Match objects
for match in re.finditer(r'\$([\d.]+)', text):
    print(f'Found: {match.group(0)} '
          f'(amount: {match.group(1)}) '
          f'at {match.start()}')

findall() returns simple string matches, while finditer() provides full Match objects with groups, spans, and positions.

import re

# Simple replacement
result = re.sub(r'\s+', '-', 'hello   world   python')
print(result)  # 'hello-world-python'

# Using backreferences
result = re.sub(r'(\w+) (\w+)', r'\2 \1', 'Hello World')
print(result)  # 'World Hello'

# Using a replacement function
def capitalize(match):
    return match.group(0).upper()

result = re.sub(r'\b[a-z]', capitalize, 'hello world')
print(result)  # 'Hello World'

# subn() also returns the count of replacements
result, count = re.subn(r'\d', '#', 'a1b2c3')
print(f'{result} ({count} replacements)')
# 'a#b#c# (3 replacements)'

re.sub() supports string replacements with backreferences, callable replacements, and subn() returns the replacement count.

import re

pattern = re.compile(
    r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})'
)
match = pattern.search('Date: 2024-01-15')

if match:
    print(match.group('year'))   # '2024'
    print(match.group('month'))  # '01'
    print(match.group('day'))    # '15'
    print(match.groupdict())
    # {'year': '2024', 'month': '01', 'day': '15'}

# Named groups in substitution
result = pattern.sub(
    r'\g<month>/\g<day>/\g<year>',
    '2024-01-15'
)
print(result)  # '01/15/2024'

Python uses (?P<name>...) syntax for named groups. Access via group("name") or groupdict(). Use \g<name> in replacements.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    // MustCompile panics on invalid pattern (use at init)
    re := regexp.MustCompile(`\d{4}-\d{2}-\d{2}`)

    // Compile returns an error for invalid patterns
    re2, err := regexp.Compile(`[a-z]+`)
    if err != nil {
        fmt.Println("Invalid pattern:", err)
        return
    }

    // POSIX mode uses leftmost-longest matching
    rePosix := regexp.MustCompilePOSIX(`[a-z]+`)

    fmt.Println(re, re2, rePosix)
}

Go uses the regexp package with RE2 syntax (no backreferences or lookaheads). MustCompile panics on error, Compile returns it.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile(`^\d{3}-\d{2}-\d{4}$`)

    // MatchString tests if string matches
    fmt.Println(re.MatchString("123-45-6789")) // true
    fmt.Println(re.MatchString("invalid"))      // false

    // FindString returns the first match
    re2 := regexp.MustCompile(`\d+`)
    fmt.Println(re2.FindString("abc 123 def 456")) // "123"

    // FindStringIndex returns match position
    loc := re2.FindStringIndex("abc 123")
    fmt.Println(loc) // [4 7]
}

MatchString() for boolean checks, FindString() for first match, FindStringIndex() for match positions.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    text := "Prices: $9.99, $24.50, and $149.00"
    re := regexp.MustCompile(`\$[\d.]+`)

    // FindAllString returns all matches (-1 = no limit)
    matches := re.FindAllString(text, -1)
    fmt.Println(matches) // [$9.99 $24.50 $149.00]

    // FindAllStringIndex returns positions
    indices := re.FindAllStringIndex(text, -1)
    for _, idx := range indices {
        fmt.Printf("Match at [%d:%d]: %s\n",
            idx[0], idx[1], text[idx[0]:idx[1]])
    }

    // Limit number of matches
    first2 := re.FindAllString(text, 2)
    fmt.Println(first2) // [$9.99 $24.50]
}

FindAllString() retrieves all matches with an optional count limit. Use -1 for no limit. Index variants return match positions.

package main

import (
    "fmt"
    "regexp"
    "strings"
)

func main() {
    re := regexp.MustCompile(`\s+`)

    // ReplaceAllString for simple replacements
    result := re.ReplaceAllString("hello   world   go", "-")
    fmt.Println(result) // "hello-world-go"

    // ReplaceAllStringFunc for dynamic replacements
    re2 := regexp.MustCompile(`\b[a-z]`)
    result2 := re2.ReplaceAllStringFunc(
        "hello world", strings.ToUpper,
    )
    fmt.Println(result2) // "Hello World"

    // Using $1 group references
    re3 := regexp.MustCompile(`(\w+)\s(\w+)`)
    result3 := re3.ReplaceAllString(
        "Hello World", "${2} ${1}",
    )
    fmt.Println(result3) // "World Hello"
}

ReplaceAllString() handles simple replacements, ReplaceAllStringFunc() for dynamic transformations, and ${n} for group references.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile(
        `(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})`,
    )
    match := re.FindStringSubmatch("Date: 2024-01-15")
    names := re.SubexpNames()

    if len(match) > 0 {
        for i, name := range names {
            if name != "" {
                fmt.Printf("%s: %s\n", name, match[i])
            }
        }
        // year: 2024
        // month: 01
        // day: 15
    }

    // Build a map of named groups
    result := make(map[string]string)
    for i, name := range names {
        if i != 0 && name != "" {
            result[name] = match[i]
        }
    }
    fmt.Println(result) // map[day:15 month:01 year:2024]
}

Go uses (?P<name>...) syntax. Access named groups via SubexpNames() combined with FindStringSubmatch() results.

use regex::Regex;
use std::sync::LazyLock;

// Compile at runtime
let re = Regex::new(r"\d{4}-\d{2}-\d{2}").unwrap();

// Compile once with LazyLock for reuse (static lifetime)
static EMAIL_RE: LazyLock<Regex> = LazyLock::new(|| {
    Regex::new(
        r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
    ).unwrap()
});

// Handle compilation errors
match Regex::new(r"[invalid") {
    Ok(re) => println!("Valid: {}", re),
    Err(e) => println!("Error: {}", e),
}

Rust uses the regex crate. Regex::new() returns a Result. Use LazyLock for static patterns. Raw strings r"..." avoid escaping.

use regex::Regex;

fn main() {
    let re = Regex::new(r"^\d{3}-\d{2}-\d{4}$").unwrap();

    // is_match() for boolean checks
    println!("{}", re.is_match("123-45-6789")); // true
    println!("{}", re.is_match("invalid"));      // false

    // find() returns the first Match
    let re2 = Regex::new(r"\d+").unwrap();
    if let Some(m) = re2.find("abc 123 def 456") {
        println!(
            "Found: {} at {}..{}",
            m.as_str(), m.start(), m.end()
        );
        // Found: 123 at 4..7
    }
}

is_match() for boolean tests, find() returns an Option<Match> with the matched text and byte positions.

use regex::Regex;

fn main() {
    let text = "Prices: $9.99, $24.50, and $149.00";
    let re = Regex::new(r"\$[\d.]+").unwrap();

    // find_iter() returns iterator of Match objects
    for m in re.find_iter(text) {
        println!(
            "Found: {} at {}..{}",
            m.as_str(), m.start(), m.end()
        );
    }

    // Collect into a Vec
    let matches: Vec<&str> = re
        .find_iter(text)
        .map(|m| m.as_str())
        .collect();
    println!("{:?}", matches);
    // ["$9.99", "$24.50", "$149.00"]

    // captures_iter() for groups
    let re2 = Regex::new(r"\$(\d+)\.(\d{2})").unwrap();
    for cap in re2.captures_iter(text) {
        println!("Dollars: {}, Cents: {}", &cap[1], &cap[2]);
    }
}

find_iter() yields Match objects, captures_iter() yields Captures for accessing groups. Collect into Vec for storage.

use regex::Regex;

fn main() {
    let re = Regex::new(r"\s+").unwrap();

    // replace_all() replaces all occurrences
    let result = re.replace_all(
        "hello   world   rust", "-"
    );
    println!("{}", result); // "hello-world-rust"

    // Using capture group references
    let re2 = Regex::new(r"(\w+)\s(\w+)").unwrap();
    let result2 = re2.replace("Hello World", "$2 $1");
    println!("{}", result2); // "World Hello"

    // Using a closure for dynamic replacement
    let re3 = Regex::new(r"\b[a-z]").unwrap();
    let result3 = re3.replace_all(
        "hello world",
        |caps: &regex::Captures| {
            caps[0].to_uppercase()
        }
    );
    println!("{}", result3); // "Hello World"
}

replace() handles first match, replace_all() handles all. Supports $n group references and closure-based dynamic replacements.

use regex::Regex;

fn main() {
    let re = Regex::new(
        r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})"
    ).unwrap();

    if let Some(caps) = re.captures("Date: 2024-01-15") {
        println!("Year: {}",  &caps["year"]);  // 2024
        println!("Month: {}", &caps["month"]); // 01
        println!("Day: {}",   &caps["day"]);   // 15

        // Access by name or by index
        println!("Full: {}",  &caps[0]); // 2024-01-15
    }

    // Named groups in replacement
    let result = re.replace(
        "2024-01-15", "$month/$day/$year"
    );
    println!("{}", result); // "01/15/2024"
}

Rust uses (?P<name>...) syntax. Access named groups via &caps["name"] or by index. Use $name in replacement strings.