Regular Expressions Guide: Master Pattern Matching and Text Validation

const regex = /hello/;

console.log(regex.test('hello world'));      // true
console.log(regex.test('Hello world'));      // false (case-sensitive)
console.log(regex.test('say hello'));        // true
console.log(regex.test('goodbye'));          // false

// . matches any character
/h.t/.test('hat');     // true
/h.t/.test('hot');     // true
/h.t/.test('h t');     // true
/h.t/.test('ht');      // false

// ^ matches start
/^hello/.test('hello world');     // true
/^hello/.test('say hello');       // false

// $ matches end
/world$/.test('hello world');     // true
/world$/.test('world hello');     // false

// * matches 0 or more
/ab*c/.test('ac');     // true (0 b's)
/ab*c/.test('abc');    // true (1 b)
/ab*c/.test('abbbbc'); // true (4 b's)

// Match literal dot
/example\.com/.test('example.com');     // true
/example.com/.test('exampleXcom');       // true (. matches any char)

// Match literal question mark
/What\?/.test('What?');                 // true

// Match literal parentheses
/\(test\)/.test('(test)');             // true

// Match literal backslash
/path\\file/.test('path\\file');     // true

// Match any vowel
/[aeiou]/.test('hello');                 // true (matches 'e')

// Match any digit
/[0-9]/.test('Room 42');                 // true (matches '4')

// Match any letter (upper or lower)
/[a-zA-Z]/.test('Hello123');             // true

// Match anything except digits
/[^0-9]/.test('abc');                    // true
/[^0-9]/.test('123');                    // false

// Multiple ranges
/[a-z0-9_-]/.test('user_name-123');      // true

// \d - Digit
/\d+/.test('Room 42');                   // true

// \w - Word character
/\w+/.test('hello_world123');           // true

// \s - Whitespace
/hello\sworld/.test('hello world');     // true

// Negated versions
/\D+/.test('abc');                      // true (non-digits)
/\W+/.test('!!!');                      // true (non-word chars)
/\S+/.test('hello');                    // true (non-whitespace)

// Practical example: Extract numbers
const text = 'Price: $42.99';
const price = text.match(/\d+\.\d+/);  // ['42.99']

// * - 0 or more
/ab*c/.test('ac');        // true
/ab*c/.test('abbbbc');    // true

// + - 1 or more
/ab+c/.test('ac');        // false
/ab+c/.test('abc');       // true
/ab+c/.test('abbbbc');    // true

// ? - 0 or 1 (optional)
/colou?r/.test('color');  // true
/colou?r/.test('colour'); // true

// {n} - Exactly n
/\d{3}/.test('123');     // true
/\d{3}/.test('12');      // false

// {n,} - n or more
/\d{2,}/.test('1');      // false
/\d{2,}/.test('123');    // true

// {n,m} - Between n and m
/\d{2,4}/.test('1');     // false
/\d{2,4}/.test('12');    // true
/\d{2,4}/.test('1234');  // true
/\d{2,4}/.test('12345'); // true (matches first 4)

const html = '<div>Hello</div><div>World</div>';

// Greedy (default) - matches as much as possible
const greedy = /<div>.*<\/div>/;
console.log(html.match(greedy)[0]);
// '<div>Hello</div><div>World</div>' (entire string)

// Lazy - matches as little as possible
const lazy = /<div>.*?<\/div>/;
console.log(html.match(lazy)[0]);
// '<div>Hello</div>' (first tag only)

// All lazy quantifiers
const text = 'aaaa';
/a*?/.exec(text);   // '' (0 a's)
/a+?/.exec(text);   // 'a' (1 a)
/a??/.exec(text);   // '' (0 a's)
/a{2,4}?/.exec(text); // 'aa' (minimum 2)

// ^ - Start of string
/^hello/.test('hello world');      // true
/^hello/.test('say hello');        // false

// $ - End of string
/world$/.test('hello world');      // true
/world$/.test('world hello');      // false

// Both anchors - exact match
/^hello$/.test('hello');           // true
/^hello$/.test('hello world');     // false

// \b - Word boundary
/\bcat\b/.test('cat');           // true
/\bcat\b/.test('category');      // false
/\bcat\b/.test('the cat sat');   // true

// \B - Non-word boundary
/\Bcat\B/.test('concatenate');   // true
/\Bcat\B/.test('cat');           // false

const text = 'The cat in the cathedral';

// Without word boundary
text.match(/cat/g);           // ['cat', 'cat'] (in 'cat' and 'cathedral')

// With word boundary
text.match(/\bcat\b/g);     // ['cat'] (only whole word)

// Practical use: Find whole words
function findWord(text, word) {
  const regex = new RegExp(`\\b${word}\\b`, 'gi');
  return text.match(regex);
}

findWord('I love cats and catnip', 'cat');  // ['cat']
findWord('cat category', 'cat');            // ['cat']

// Basic capturing
const date = '2024-12-31';
const match = date.match(/(\d{4})-(\d{2})-(\d{2})/);

console.log(match[0]);  // '2024-12-31' (full match)
console.log(match[1]);  // '2024' (first group)
console.log(match[2]);  // '12' (second group)
console.log(match[3]);  // '31' (third group)

// Named groups (modern JavaScript)
const regex = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
const { year, month, day } = date.match(regex).groups;

console.log(year);   // '2024'
console.log(month);  // '12'
console.log(day);    // '31'

// With capturing groups (less efficient)
const withCapture = /(\d{2}):(\d{2}):(\d{2})/;
'12:34:56'.match(withCapture);
// ['12:34:56', '12', '34', '56']

// With non-capturing groups (more efficient when you don't need captures)
const withoutCapture = /(?:\d{2}):(?:\d{2}):(?:\d{2})/;
'12:34:56'.match(withoutCapture);
// ['12:34:56']

// Mixed: Capture what you need
const mixed = /(\d{2}):(?:\d{2}):(\d{2})/;
'12:34:56'.match(mixed);
// ['12:34:56', '12', '56'] (only hour and second captured)

// Named groups for readability
const phoneRegex = /(?<area>\d{3})-(?<exchange>\d{3})-(?<number>\d{4})/;
const match = '555-123-4567'.match(phoneRegex);

console.log(match.groups.area);      // '555'
console.log(match.groups.exchange);  // '123'
console.log(match.groups.number);    // '4567'

// Use in replace
const formatted = '555-123-4567'.replace(
  phoneRegex,
  '($<area>) $<exchange>-$<number>'
);
console.log(formatted);  // '(555) 123-4567'

// Match repeated words
/\b(\w+)\s+\1\b/.test('hello hello');     // true
/\b(\w+)\s+\1\b/.test('hello world');     // false

// Match HTML tags
/<([a-z]+)>.*?<\/\1>/.test('<div>text</div>');    // true
/<([a-z]+)>.*?<\/\1>/.test('<div>text</span>');   // false

// Find duplicated words
const text = 'The the cat sat sat on the mat';
const duplicates = text.match(/\b(\w+)\s+\1\b/gi);
console.log(duplicates);  // ['The the', 'sat sat']

// Match quotes
const quoted = /(["']).*?\1/;
quoted.test('"hello"');   // true
quoted.test("'hello'");   // true
quoted.test('"hello\'');  // false

// Very simple - just checks for @ sign
const simpleEmail = /^.+@.+\..+$/;

simpleEmail.test('[email protected]');     // true
simpleEmail.test('invalid');              // false

// Slightly better
const betterEmail = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

betterEmail.test('[email protected]');     // true
betterEmail.test('user @example.com');    // false (space)
betterEmail.test('user@example');         // false (no TLD)

// Standard email pattern (most common use)
const emailRegex = /^[a-zA-Z0-9._%-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;

emailRegex.test('[email protected]');           // true
emailRegex.test('[email protected]');      // true
emailRegex.test('[email protected]');     // true
emailRegex.test('invalid@');                   // false
emailRegex.test('@example.com');               // false

// Function wrapper
function isValidEmail(email) {
  const regex = /^[a-zA-Z0-9._%-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
  return regex.test(email);
}

// RFC 5322 compliant (very permissive)
const comprehensiveEmail = /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i;

// More practical comprehensive version
const email = /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$/i;

// Note: For production, consider using a validation library
// or simply checking for @ and basic format, then verifying via email

// US phone number formats
const patterns = {
  // 123-456-7890
  dashes: /^\d{3}-\d{3}-\d{4}$/,

  // (123) 456-7890
  parens: /^\(\d{3}\)\s?\d{3}-\d{4}$/,

  // 123.456.7890
  dots: /^\d{3}\.\d{3}\.\d{4}$/,

  // 1234567890
  plain: /^\d{10}$/,

  // +1 (123) 456-7890
  international: /^\+?1?\s?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4}$/
};

patterns.dashes.test('123-456-7890');         // true
patterns.parens.test('(123) 456-7890');       // true
patterns.international.test('+1 (123) 456-7890'); // true

// Flexible US phone number
const phoneRegex = /^\+?1?\s?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4}$/;

function isValidPhone(phone) {
  return phoneRegex.test(phone);
}

isValidPhone('123-456-7890');          // true
isValidPhone('(123) 456-7890');        // true
isValidPhone('123.456.7890');          // true
isValidPhone('1234567890');            // true
isValidPhone('+1 (123) 456-7890');     // true
isValidPhone('12345');                 // false

// Extract digits only
function normalizePhone(phone) {
  return phone.replace(/\D/g, '').slice(-10);
}

normalizePhone('+1 (123) 456-7890');   // '1234567890'

// Simple URL
const simpleUrl = /^https?:\/\/.+/;

// Standard URL pattern
const urlRegex = /^https?:\/\/([a-z0-9-]+\.)+[a-z]{2,}(\/.*)?$/i;

// Comprehensive URL
const url = /^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)$/;

function isValidUrl(string) {
  try {
    new URL(string);
    return true;
  } catch (_) {
    return false;
  }
}

// Better: Use URL API for validation
urlRegex.test('https://example.com');          // true
urlRegex.test('http://sub.example.com/path');  // true
urlRegex.test('not a url');                    // false

// Minimum 8 characters
const minLength = /^.{8,}$/;

// At least one uppercase letter
const hasUpper = /[A-Z]/;

// At least one lowercase letter
const hasLower = /[a-z]/;

// At least one digit
const hasDigit = /\d/;

// At least one special character
const hasSpecial = /[!@#$%^&*(),.?":{}|<>]/;

// Check password strength
function checkPasswordStrength(password) {
  return {
    length: minLength.test(password),
    uppercase: hasUpper.test(password),
    lowercase: hasLower.test(password),
    digit: hasDigit.test(password),
    special: hasSpecial.test(password)
  };
}

const result = checkPasswordStrength('Pass123!');
console.log(result);
// { length: true, uppercase: true, lowercase: true, digit: true, special: true }

// Strong password: 8+ chars, upper, lower, digit, special
const strongPassword = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;

strongPassword.test('Weak');              // false
strongPassword.test('Password123');       // false (no special)
strongPassword.test('Pass123!');          // true

// Medium password: 8+ chars, upper, lower, digit
const mediumPassword = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[A-Za-z\d@$!%*?&]{8,}$/;

mediumPassword.test('Password123');       // true

// Function with detailed feedback
function validatePassword(password) {
  const rules = {
    minLength: password.length >= 8,
    hasUpper: /[A-Z]/.test(password),
    hasLower: /[a-z]/.test(password),
    hasDigit: /\d/.test(password),
    hasSpecial: /[!@#$%^&*(),.?":{}|<>]/.test(password)
  };

  const strength = Object.values(rules).filter(Boolean).length;

  return {
    valid: Object.values(rules).every(Boolean),
    strength: strength === 5 ? 'strong' :
              strength >= 3 ? 'medium' : 'weak',
    rules
  };
}

// YYYY-MM-DD (ISO 8601)
const isoDate = /^\d{4}-\d{2}-\d{2}$/;

// MM/DD/YYYY
const usDate = /^\d{2}\/\d{2}\/\d{4}$/;

// DD/MM/YYYY
const ukDate = /^\d{2}\/\d{2}\/\d{4}$/;

// DD-MM-YYYY
const hyphenDate = /^\d{2}-\d{2}-\d{4}$/;

// More strict ISO date (validates ranges)
const strictIsoDate = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;

strictIsoDate.test('2024-12-31');   // true
strictIsoDate.test('2024-13-01');   // false (invalid month)
strictIsoDate.test('2024-12-32');   // false (invalid day)

// Note: Use Date object for full validation
function isValidDate(dateString) {
  const date = new Date(dateString);
  return date instanceof Date && !isNaN(date);
}

// Integer
const integer = /^-?\d+$/;

// Positive integer
const positiveInt = /^\d+$/;

// Decimal number
const decimal = /^-?\d+\.\d+$/;

// Number (integer or decimal)
const number = /^-?\d+(\.\d+)?$/;

// Currency (US dollars)
const currency = /^\$?\d{1,3}(,\d{3})*(\.\d{2})?$/;

// Percentage
const percentage = /^\d+(\.\d+)?%$/;

// Scientific notation
const scientific = /^-?\d+(\.\d+)?[eE][+-]?\d+$/;

// Test examples
currency.test('$1,234.56');      // true
currency.test('1234.56');        // true
percentage.test('50%');          // true
percentage.test('99.99%');       // true
scientific.test('1.23e-4');      // true

// Alphanumeric, 3-16 characters
const username = /^[a-zA-Z0-9]{3,16}$/;

// Alphanumeric plus underscore and hyphen, 3-20 characters
const flexibleUsername = /^[a-zA-Z0-9_-]{3,20}$/;

// Must start with letter, 3-16 characters
const letterStartUsername = /^[a-zA-Z][a-zA-Z0-9_-]{2,15}$/;

// Cannot start or end with special chars
const cleanUsername = /^[a-zA-Z0-9]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;

username.test('user123');              // true
username.test('a');                    // false (too short)
letterStartUsername.test('1user');     // false (starts with digit)
letterStartUsername.test('user_123');  // true

// Visa (starts with 4, 13 or 16 digits)
const visa = /^4\d{12}(?:\d{3})?$/;

// MasterCard (starts with 51-55 or 2221-2720, 16 digits)
const mastercard = /^(?:5[1-5]\d{2}|222[1-9]|22[3-9]\d|2[3-6]\d{2}|27[01]\d|2720)\d{12}$/;

// American Express (starts with 34 or 37, 15 digits)
const amex = /^3[47]\d{13}$/;

// Discover (starts with 6011, 622126-622925, 644-649, or 65, 16 digits)
const discover = /^6(?:011|5\d{2}|4[4-9]\d|22(?:12[6-9]|1[3-9]\d|[2-8]\d{2}|9[01]\d|92[0-5]))\d{12}$/;

// Any card (remove spaces/hyphens first)
function validateCard(cardNumber) {
  const cleaned = cardNumber.replace(/[\s-]/g, '');

  if (visa.test(cleaned)) return 'Visa';
  if (mastercard.test(cleaned)) return 'MasterCard';
  if (amex.test(cleaned)) return 'American Express';
  if (discover.test(cleaned)) return 'Discover';

  return null;
}

// Note: Always use Luhn algorithm for full validation

// Literal notation
const regex1 = /pattern/flags;
const regex2 = /\d{3}-\d{4}/g;

// Constructor (dynamic patterns)
const pattern = 'hello';
const regex3 = new RegExp(pattern, 'gi');

// Escaping in constructor
const search = 'example.com';
const regex4 = new RegExp(search.replace(/[.*+?^$\{\}()|[\]\\]/g, '\\$&'));

// Flags
const flags = {
  g: 'global',
  i: 'case-insensitive',
  m: 'multiline',
  s: 'dotAll',
  u: 'unicode',
  y: 'sticky'
};

const text = 'The price is $42.99';

// test() - returns boolean
const hasPrice = /\$\d+\.\d{2}/.test(text);
console.log(hasPrice);  // true

// match() - returns array or null
const price = text.match(/\$(\d+\.\d{2})/);
console.log(price[0]);  // '$42.99'
console.log(price[1]);  // '42.99'

// matchAll() - returns iterator (use with g flag)
const text2 = 'Items: $10.50, $25.99, $5.00';
const prices = [...text2.matchAll(/\$(\d+\.\d{2})/g)];
prices.forEach(match => console.log(match[1]));
// '10.50', '25.99', '5.00'

// exec() - returns match with index
const regex = /\d+/g;
let match;
while ((match = regex.exec('a1b2c3')) !== null) {
  console.log(`Found ${match[0]} at index ${match.index}`);
}

const text = 'Hello World';

// Simple replacement
text.replace(/World/, 'Universe');
// 'Hello Universe'

// Global replacement
'a b c a b c'.replace(/a/g, 'X');
// 'X b c X b c'

// Using function
text.replace(/\w+/g, match => match.toUpperCase());
// 'HELLO WORLD'

// Using groups
'John Doe'.replace(/(\w+)\s(\w+)/, '$2, $1');
// 'Doe, John'

// Named groups
'2024-12-31'.replace(
  /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/,
  '$<month>/$<day>/$<year>'
);
// '12/31/2024'

// replaceAll() (ES2021)
'a b a b'.replaceAll(/a/g, 'X');
// 'X b X b'

// Split on whitespace
'hello world  test'.split(/\s+/);
// ['hello', 'world', 'test']

// Split on multiple delimiters
'apple,banana;orange|grape'.split(/[,;|]/);
// ['apple', 'banana', 'orange', 'grape']

// Split and keep delimiters (use capturing group)
'a,b;c'.split(/([,;])/);
// ['a', ',', 'b', ';', 'c']

// Limit results
'a b c d e'.split(/\s+/, 3);
// ['a', 'b', 'c']

import re

text = 'The price is $42.99'

# search() - find first match
match = re.search(r'\$(\d+\.\d{2})', text)
if match:
    print(match.group(0))  # '$42.99'
    print(match.group(1))  # '42.99'

# findall() - find all matches
text2 = 'Items: $10.50, $25.99, $5.00'
prices = re.findall(r'\$(\d+\.\d{2})', text2)
print(prices)  # ['10.50', '25.99', '5.00']

# finditer() - iterator of match objects
for match in re.finditer(r'\d+', 'a1b2c3'):
    print(f'Found {match.group()} at {match.start()}')

import re

text = 'Hello World'

# match() - match at beginning
re.match(r'Hello', text)        # Match object
re.match(r'World', text)        # None

# search() - find anywhere
re.search(r'World', text)       # Match object

# findall() - all matches
re.findall(r'\w+', text)       # ['Hello', 'World']

# sub() - substitute
re.sub(r'World', 'Universe', text)  # 'Hello Universe'

# split() - split string
re.split(r'\s+', text)         # ['Hello', 'World']

# fullmatch() - match entire string
re.fullmatch(r'Hello World', text)  # Match object
re.fullmatch(r'Hello', text)        # None

import re

# Compile for reuse (more efficient)
pattern = re.compile(r'\d+')

# Use compiled pattern
text = 'Room 42, Floor 3'
pattern.findall(text)           # ['42', '3']
pattern.search(text)            # Match object for '42'

# With flags
email_pattern = re.compile(
    r'^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}$',
    re.IGNORECASE
)

email_pattern.match('[email protected]')  # Match object

# Verbose pattern with comments
phone_pattern = re.compile(r'''
    ^\+?1?          # Optional +1
    \s?             # Optional space
    \(?\d{3}\)?   # Area code
    [\s.-]?        # Separator
    \d{3}          # Exchange
    [\s.-]?        # Separator
    \d{4}$         # Number
''', re.VERBOSE)

<?php
$text = 'The price is $42.99';

// preg_match() - find first match
if (preg_match('/\$(\d+\.\d{2})/', $text, $matches)) {
    echo $matches[0];  // '$42.99'
    echo $matches[1];  // '42.99'
}

// preg_match_all() - find all matches
$text2 = 'Items: $10.50, $25.99, $5.00';
preg_match_all('/\$(\d+\.\d{2})/', $text2, $matches);
print_r($matches[1]);  // ['10.50', '25.99', '5.00']

// preg_replace() - search and replace
$result = preg_replace('/World/', 'Universe', 'Hello World');
echo $result;  // 'Hello Universe'

// preg_split() - split string
$parts = preg_split('/\s+/', 'Hello  World');
print_r($parts);  // ['Hello', 'World']

// Modifiers (flags)
// i - case-insensitive
// m - multiline
// s - dotall
// x - verbose
preg_match('/hello/i', 'HELLO');  // Match
?>

import java.util.regex.*;

public class RegexExample {
    public static void main(String[] args) {
        String text = "The price is $42.99";

        // Pattern and Matcher
        Pattern pattern = Pattern.compile("\\$(\\d+\\.\\d{2})");
        Matcher matcher = pattern.matcher(text);

        if (matcher.find()) {
            System.out.println(matcher.group(0));  // $42.99
            System.out.println(matcher.group(1));  // 42.99
        }

        // Find all matches
        String text2 = "Items: $10.50, $25.99, $5.00";
        matcher = pattern.matcher(text2);
        while (matcher.find()) {
            System.out.println(matcher.group(1));
        }

        // Replace
        String result = text.replaceAll("World", "Universe");

        // Split
        String[] parts = "a,b,c".split(",");

        // Flags
        Pattern caseInsensitive = Pattern.compile(
            "hello",
            Pattern.CASE_INSENSITIVE
        );
    }
}

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string text = "The price is $42.99";

        // Match
        Match match = Regex.Match(text, @"\$(\d+\.\d{2})");
        if (match.Success)
        {
            Console.WriteLine(match.Value);         // $42.99
            Console.WriteLine(match.Groups[1].Value); // 42.99
        }

        // Find all
        string text2 = "Items: $10.50, $25.99, $5.00";
        MatchCollection matches = Regex.Matches(text2, @"\$(\d+\.\d{2})");
        foreach (Match m in matches)
        {
            Console.WriteLine(m.Groups[1].Value);
        }

        // Replace
        string result = Regex.Replace("Hello World", "World", "Universe");

        // Split
        string[] parts = Regex.Split("a,b,c", ",");

        // Options (flags)
        Match caseInsensitive = Regex.Match(
            "HELLO",
            "hello",
            RegexOptions.IgnoreCase
        );
    }
}

text = 'The price is $42.99'

# Match
if match = text.match(/\$(\d+\.\d{2})/)
  puts match[0]  # '$42.99'
  puts match[1]  # '42.99'
end

# Scan (find all)
text2 = 'Items: $10.50, $25.99, $5.00'
prices = text2.scan(/\$(\d+\.\d{2})/)
puts prices.inspect  # [['10.50'], ['25.99'], ['5.00']]

# Replace
result = 'Hello World'.sub(/World/, 'Universe')    # First match
result = 'a b a b'.gsub(/a/, 'X')                  # All matches

# Split
parts = 'a,b,c'.split(/,/)

# Case-insensitive
/hello/i.match('HELLO')  # Match

# Named groups
match = '2024-12-31'.match(/(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/)
puts match[:year]   # '2024'
puts match[:month]  # '12'

package main

import (
    "fmt"
    "regexp"
)

func main() {
    text := "The price is $42.99"

    // Compile pattern
    pattern := regexp.MustCompile(`\$(\d+\.\d{2})`)

    // Find first match
    match := pattern.FindStringSubmatch(text)
    if match != nil {
        fmt.Println(match[0])  // $42.99
        fmt.Println(match[1])  // 42.99
    }

    // Find all matches
    text2 := "Items: $10.50, $25.99, $5.00"
    matches := pattern.FindAllStringSubmatch(text2, -1)
    for _, match := range matches {
        fmt.Println(match[1])
    }

    // Replace
    result := pattern.ReplaceAllString(text, "FREE")

    // Split
    splitter := regexp.MustCompile(`,`)
    parts := splitter.Split("a,b,c", -1)
}

// Positive lookahead (?=...)
// Match 'foo' only if followed by 'bar'
/foo(?=bar)/.test('foobar');    // true
/foo(?=bar)/.test('foobaz');    // false

// Negative lookahead (?!...)
// Match 'foo' only if NOT followed by 'bar'
/foo(?!bar)/.test('foobaz');    // true
/foo(?!bar)/.test('foobar');    // false

// Positive lookbehind (?<=...)
// Match 'bar' only if preceded by 'foo'
/(?<=foo)bar/.test('foobar');   // true
/(?<=foo)bar/.test('bazbar');   // false

// Negative lookbehind (?<!...)
// Match 'bar' only if NOT preceded by 'foo'
/(?<!foo)bar/.test('bazbar');   // true
/(?<!foo)bar/.test('foobar');   // false

// Practical: Extract price without currency symbol
const prices = '$42.99, €35.50, £25.00';
const numbers = prices.match(/(?<=[\$€£])\d+\.\d{2}/g);
console.log(numbers);  // ['42.99', '35.50', '25.00']

// Password must contain:
// - At least 8 characters
// - At least one uppercase letter
// - At least one lowercase letter
// - At least one digit
// - At least one special character

const passwordRegex = /^
  (?=.*[a-z])           // At least one lowercase
  (?=.*[A-Z])           // At least one uppercase
  (?=.*\d)              // At least one digit
  (?=.*[@$!%*?&])       // At least one special
  [A-Za-z\d@$!%*?&]    // Allowed characters
  {8,}                  // At least 8 characters
$/x;

// JavaScript version (no x flag)
const password = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;

password.test('Weak');          // false
password.test('Password123');   // false (no special char)
password.test('Pass123!');      // true

// Match 'color' or 'colour' (simple alternation)
/colou?r/.test('color');    // true
/colou?r/.test('colour');   // true

// Match different formats
/(\d{3})-(\d{3})-(\d{4})|(\d{10})/.test('123-456-7890');  // true
/(\d{3})-(\d{3})-(\d{4})|(\d{10})/.test('1234567890');    // true

// Conditional based on group (PCRE, not JavaScript)
// In PCRE: (?(condition)yes-pattern|no-pattern)
// Example: Match <tag>text</tag> or plain text
// Not directly supported in JavaScript

// Workaround in JavaScript using multiple patterns
function matchConditional(text) {
  if (/<(\w+)>/.test(text)) {
    // If has opening tag, require closing tag
    return /<(\w+)>.*?<\/\1>/.test(text);
  } else {
    // Otherwise, match plain text
    return /^\w+$/.test(text);
  }
}

<?php
// Match nested parentheses (PCRE)
$pattern = '/\((?:[^()]|(?R))*\)/';

$text1 = '(a(b(c)d)e)';
$text2 = '(a(b)c';

preg_match($pattern, $text1);  // Match
preg_match($pattern, $text2);  // No match (unclosed)

// Match balanced brackets
$balanced = '/^\((?:[^()]++|(?R))*\)$/';

preg_match($balanced, '((()))');      // Match
preg_match($balanced, '((())');       // No match

// Note: Recursive patterns not supported in JavaScript
// Use stack-based parsing instead for nested structures
?>

// BAD: Catastrophic backtracking
const bad = /(a+)+b/;
// On input "aaaaaaaaaaaac", regex tries exponential combinations
// Runtime grows exponentially with input length

// GOOD: Simplified pattern
const good = /a+b/;
// Linear time complexity

// Another bad example
const badEmail = /^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/;
// On "a@a." + "a".repeat(50), causes excessive backtracking

// Better: More specific, less backtracking
const goodEmail = /^[a-z0-9_\.-]+@[a-z0-9\.-]+\.[a-z]{2,6}$/;

// Atomic groups prevent backtracking (not in JavaScript)
// In PCRE: (?>a+)b
// JavaScript: Use simpler patterns or different approach

// Slow: Backtracking on every character
const slow = /.*foo/;

// Fast: Anchor to reduce search space
const fast = /^.*foo/;

// Slow: Non-specific character class
const slowEmail = /.+@.+\..+/;

// Fast: Specific character classes
const fastEmail = /[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}/i;

// Slow: Capturing when not needed
const slowGroups = /(\d{3})-(\d{3})-(\d{4})/;

// Fast: Non-capturing groups
const fastGroups = /(?:\d{3})-(?:\d{3})-(?:\d{4})/;

// Pre-compile frequently used patterns
const compiled = /pattern/g;
for (let i = 0; i < 1000; i++) {
  compiled.test(text);  // Reuse compiled pattern
}

// Avoid alternation when possible
const slowAlternation = /foo|food/;
const fastPrefix = /foo(?:d)?/;

class FormValidator {
  static patterns = {
    email: /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
    phone: /^\+?1?\s?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4}$/,
    zipCode: /^\d{5}(-\d{4})?$/,
    username: /^[a-zA-Z0-9_-]{3,20}$/,
    password: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/,
    url: /^https?:\/\/([a-z0-9-]+\.)+[a-z]{2,}(\/.*)?$/i,
    creditCard: /^\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}$/
  };

  static validate(field, value) {
    const pattern = this.patterns[field];
    if (!pattern) return { valid: false, error: 'Unknown field type' };

    const valid = pattern.test(value);
    return {
      valid,
      error: valid ? null : `Invalid ${field} format`
    };
  }

  static validateForm(formData) {
    const errors = {};

    for (const [field, value] of Object.entries(formData)) {
      const result = this.validate(field, value);
      if (!result.valid) {
        errors[field] = result.error;
      }
    }

    return {
      valid: Object.keys(errors).length === 0,
      errors
    };
  }
}

// Usage
const result = FormValidator.validateForm({
  email: '[email protected]',
  phone: '555-123-4567',
  username: 'john_doe',
  password: 'Pass123!'
});

console.log(result);

// Extract email addresses from text
function extractEmails(text) {
  const emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
  return text.match(emailRegex) || [];
}

// Extract URLs
function extractUrls(text) {
  const urlRegex = /https?:\/\/[^\s<>"{}|\\^[`]+/g;
  return text.match(urlRegex) || [];
}

// Extract phone numbers
function extractPhones(text) {
  const phoneRegex = /\+?1?\s?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4}/g;
  return text.match(phoneRegex) || [];
}

// Extract hashtags
function extractHashtags(text) {
  const hashtagRegex = /#\w+/g;
  return text.match(hashtagRegex) || [];
}

// Extract mentions
function extractMentions(text) {
  const mentionRegex = /@\w+/g;
  return text.match(mentionRegex) || [];
}

// Usage
const text = `
  Contact us at [email protected] or visit https://example.com
  Call 555-123-4567 or follow @company #tech #innovation
`;

console.log(extractEmails(text));     // ['[email protected]']
console.log(extractUrls(text));       // ['https://example.com']
console.log(extractPhones(text));     // ['555-123-4567']
console.log(extractHashtags(text));   // ['#tech', '#innovation']
console.log(extractMentions(text));   // ['@company']

// Parse Apache log format
const logRegex = /^(\S+) \S+ \S+ \[([\w:\/]+\s[+\-]\d{4})\] "(.+?)" (\d{3}) (\d+|-)/;

function parseLogLine(line) {
  const match = line.match(logRegex);
  if (!match) return null;

  return {
    ip: match[1],
    timestamp: match[2],
    request: match[3],
    statusCode: parseInt(match[4]),
    size: match[5] === '-' ? 0 : parseInt(match[5])
  };
}

// Parse error levels
function parseErrorLog(line) {
  const errorRegex = /^\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\] (\w+): (.+)$/;
  const match = line.match(errorRegex);

  if (!match) return null;

  return {
    timestamp: match[1],
    level: match[2],
    message: match[3]
  };
}

// Usage
const logLine = '192.168.1.1 - - [01/Jan/2024:12:00:00 +0000] "GET /index.html HTTP/1.1" 200 1234';
const errorLine = '[2024-01-01 12:00:00] ERROR: Database connection failed';

console.log(parseLogLine(logLine));
console.log(parseErrorLog(errorLine));

function highlightCode(code) {
  // Keywords
  code = code.replace(
    /\b(function|const|let|var|if|else|for|while|return)\b/g,
    '<span class="keyword">$1</span>'
  );

  // Strings
  code = code.replace(
    /(["'])(?:(?=(\\?))\2.)*?\1/g,
    '<span class="string">$&</span>'
  );

  // Numbers
  code = code.replace(
    /\b\d+(\.\d+)?\b/g,
    '<span class="number">$&</span>'
  );

  // Comments
  code = code.replace(
    /\/\/.*$/gm,
    '<span class="comment">$&</span>'
  );

  // Functions
  code = code.replace(
    /\b([a-zA-Z_$][a-zA-Z0-9_$]*)(?=\s*\()/g,
    '<span class="function">$1</span>'
  );

  return code;
}

// Usage
const code = `
function greet(name) {
  const message = "Hello, " + name;
  return message; // Return greeting
}
`;

console.log(highlightCode(code));

// Remove HTML tags
function stripHtml(text) {
  return text.replace(/<[^>]*>/g, '');
}

// Remove extra whitespace
function normalizeWhitespace(text) {
  return text.replace(/\s+/g, ' ').trim();
}

// Remove special characters
function removeSpecialChars(text) {
  return text.replace(/[^a-zA-Z0-9\s]/g, '');
}

// Escape HTML entities
function escapeHtml(text) {
  return text
    .replace(/&/g, '&amp;')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;')
    .replace(/'/g, '&#039;');
}

// Sanitize filename
function sanitizeFilename(filename) {
  return filename
    .replace(/[^a-zA-Z0-9._-]/g, '_')
    .replace(/_{2,}/g, '_');
}

// Remove SQL injection attempts
function sanitizeSql(input) {
  return input.replace(/['";\-\/\\]/g, '');
}

// Usage
console.log(stripHtml('<p>Hello <b>World</b></p>'));
// 'Hello World'

console.log(normalizeWhitespace('Hello    World  '));
// 'Hello World'

console.log(sanitizeFilename('my file (2023).txt'));
// 'my_file_2023.txt'

// Build complex pattern step by step

// Step 1: Match any email
let regex = /.+@.+/;

// Step 2: Require domain extension
regex = /.+@.+\..+/;

// Step 3: Be more specific about characters
regex = /[^@]+@[^@]+\.[^@]+/;

// Step 4: Use proper character classes
regex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/;

// Step 5: Add anchors for exact match
regex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;

// Test at each step
const test = '[email protected]';
console.log(regex.test(test));

// Complex pattern: Match ISO date
const fullPattern = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;

// Test components separately
const yearPattern = /^\d{4}$/;
const monthPattern = /^(0[1-9]|1[0-2])$/;
const dayPattern = /^(0[1-9]|[12]\d|3[01])$/;

// Test each part
const year = '2024';
const month = '12';
const day = '31';

console.log('Year valid:', yearPattern.test(year));
console.log('Month valid:', monthPattern.test(month));
console.log('Day valid:', dayPattern.test(day));

// Then test full pattern
const fullDate = `${year}-${month}-${day}`;
console.log('Full date valid:', fullPattern.test(fullDate));

// Issue 1: Forgot to escape dot
const wrong1 = /example.com/;  // Matches "exampleXcom"
const right1 = /example\.com/; // Matches "example.com"

// Issue 2: Greedy vs lazy
const wrong2 = /<.*>/;         // Matches entire "<a>text</a>"
const right2 = /<.*?>/;        // Matches "<a>" only

// Issue 3: Missing anchors
const wrong3 = /\d{3}/;        // Matches "123" in "abc123def"
const right3 = /^\d{3}$/;      // Matches exactly "123"

// Issue 4: Wrong character class
const wrong4 = /[a-Z]/;        // Invalid range
const right4 = /[a-zA-Z]/;     // Correct

// Issue 5: Not escaping in character class
const wrong5 = /[a-z-]/;       // Might cause issues
const right5 = /[a-z\-]/;      // Escaped hyphen

// Issue 6: Case sensitivity
const wrong6 = /email/;        // Doesn't match "Email"
const right6 = /email/i;       // Case-insensitive

// Debugging tip: Test edge cases
function debugRegex(pattern, tests) {
  console.log(`Testing: ${pattern}`);
  tests.forEach(test => {
    const result = pattern.test(test);
    console.log(`  "${test}": ${result ? '✓' : '✗'}`);
  });
}

debugRegex(/^\d{3}$/, ['123', '12', '1234', 'abc']);