Regular Expressions

// Check if a string contains only digits
const isAllDigits = /^\d+$/.test('12345')
console.log(isAllDigits)  // true

// Find all words starting with capital letters
const text = 'Hello World from JavaScript'
const capitalWords = text.match(/\b[A-Z][a-z]*\b/g)
console.log(capitalWords)  // ["Hello", "World"]

// 1. Literal syntax (preferred for static patterns)
const pattern1 = /hello/

// 2. Constructor syntax (useful for dynamic patterns)
const pattern2 = new RegExp('hello')

// Both work the same way
console.log(pattern1.test('hello world'))  // true
console.log(pattern2.test('hello world'))  // true

function findWord(text, word) {
  const pattern = new RegExp(word, 'gi')  // case-insensitive, global
  return text.match(pattern)
}

console.log(findWord('Hello hello HELLO', 'hello'))  // ["Hello", "hello", "HELLO"]

┌─────────────────────────────────────────────────────────────────────────┐
│                         REGEX PATTERN MATCHING                           │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│   Pattern: /\d{3}-\d{4}/          String: "Call 555-1234 today"         │
│                                                                          │
│   Step 1: Find 3 digits (\d{3})   →  "555" ✓                            │
│   Step 2: Find a hyphen (-)       →  "-"   ✓                            │
│   Step 3: Find 4 digits (\d{4})   →  "1234" ✓                           │
│                                                                          │
│   Result: Match found! → "555-1234"                                      │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

// Match a phone number pattern: 3 digits, hyphen, 4 digits
const phone = /\d{3}-\d{4}/
console.log(phone.test('555-1234'))  // true
console.log(phone.test('55-1234'))   // false

// Match words (letters, digits, underscores)
const words = 'hello_world 123 test!'
console.log(words.match(/\w+/g))  // ["hello_world", "123", "test"]

// Match optional 's' for plural
const plural = /apple(s)?/
console.log(plural.test('apple'))   // true
console.log(plural.test('apples'))  // true

// Match 1 or more digits
const numbers = 'I have 42 apples and 7 oranges'
console.log(numbers.match(/\d+/g))  // ["42", "7"]

// Must start with "Hello"
console.log(/^Hello/.test('Hello World'))   // true
console.log(/^Hello/.test('Say Hello'))     // false

// Must end with a digit
console.log(/\d$/.test('Room 42'))   // true
console.log(/\d$/.test('42 rooms'))  // false

// Word boundaries prevent partial matches
console.log(/\bcat\b/.test('cat'))       // true
console.log(/\bcat\b/.test('category'))  // false (cat is part of a larger word)

const emailPattern = /\S+@\S+\.\S+/

console.log(emailPattern.test('[email protected]'))  // true
console.log(emailPattern.test('invalid-email'))     // false

const text = 'My numbers: 123, 456, 789'

// Without 'g' flag: returns first match with details
console.log(text.match(/\d+/))
// ["123", index: 12, input: "My numbers: 123, 456, 789"]

// With 'g' flag: returns all matches
console.log(text.match(/\d+/g))
// ["123", "456", "789"]

const text = 'Call 555-1234 or 555-5678'
const pattern = /(\d{3})-(\d{4})/g

for (const match of text.matchAll(pattern)) {
  console.log(`Found: ${match[0]}, Prefix: ${match[1]}, Number: ${match[2]}`)
}
// "Found: 555-1234, Prefix: 555, Number: 1234"
// "Found: 555-5678, Prefix: 555, Number: 5678"

const text = 'Hello World'
console.log(text.search(/World/))  // 6 (index where match starts)
console.log(text.search(/xyz/))    // -1 (not found)

// Replace first occurrence
console.log('hello world'.replace(/o/, '0'))
// "hell0 world"

// Replace all occurrences (with 'g' flag)
console.log('hello world'.replace(/o/g, '0'))
// "hell0 w0rld"

// Use captured groups in replacement
console.log('John Smith'.replace(/(\w+) (\w+)/, '$2, $1'))
// "Smith, John"

// Split on one or more whitespace characters
const words = 'hello   world  foo'.split(/\s+/)
console.log(words)  // ["hello", "world", "foo"]

// Split on commas with optional spaces
const items = 'a, b,c , d'.split(/\s*,\s*/)
console.log(items)  // ["a", "b", "c", "d"]

const pattern = /\d+/g
const text = 'a1b22c333'

console.log(pattern.exec(text))  // ["1", index: 1]
console.log(pattern.exec(text))  // ["22", index: 3]
console.log(pattern.exec(text))  // ["333", index: 6]
console.log(pattern.exec(text))  // null (no more matches)

// Case-insensitive matching
console.log(/hello/i.test('HELLO'))  // true

// Global: find all matches
console.log('abcabc'.match(/a/g))   // ["a", "a"]
console.log('abcabc'.match(/a/))    // ["a", index: 0, input: "abcabc", ...] (first match with details)

// Multiline: ^ and $ match each line
const multiline = 'line1\nline2\nline3'
console.log(multiline.match(/^line\d/gm))  // ["line1", "line2", "line3"]

// Extract area code and number separately
const phonePattern = /\((\d{3})\) (\d{3}-\d{4})/
const match = '(555) 123-4567'.match(phonePattern)

console.log(match[0])  // "(555) 123-4567" (full match)
console.log(match[1])  // "555" (first group)
console.log(match[2])  // "123-4567" (second group)

const datePattern = /(?<month>\d{2})-(?<day>\d{2})-(?<year>\d{4})/
const match = '12-25-2024'.match(datePattern)

console.log(match.groups.month)  // "12"
console.log(match.groups.day)    // "25"
console.log(match.groups.year)   // "2024"

// Reformat date from MM-DD-YYYY to YYYY/MM/DD
const date = '12-25-2024'
const reformatted = date.replace(
  /(\d{2})-(\d{2})-(\d{4})/,
  '$3/$1/$2'
)
console.log(reformatted)  // "2024/12/25"

┌─────────────────────────────────────────────────────────────────────────┐
│                          GREEDY VS LAZY                                  │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│   String: "<div>Hello</div><div>World</div>"                             │
│                                                                          │
│   GREEDY: /<div>.*<\/div>/        LAZY: /<div>.*?<\/div>/               │
│   Matches: "<div>Hello</div>      Matches: "<div>Hello</div>"           │
│            <div>World</div>"                                             │
│   (Everything from first          (Just the first div)                   │
│    <div> to LAST </div>)                                                 │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

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

// Greedy: matches everything between first <div> and LAST </div>
console.log(html.match(/<div>.*<\/div>/)[0])
// "<div>Hello</div><div>World</div>"

// Lazy: stops at first </div>
console.log(html.match(/<div>.*?<\/div>/)[0])
// "<div>Hello</div>"

// Email (basic validation)
const email = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
console.log(email.test('[email protected]'))  // true

// URL
const url = /^https?:\/\/[^\s]+$/
console.log(url.test('https://example.com/path'))  // true

// Phone (US format: 123-456-7890 or (123) 456-7890)
const phone = /^(\(\d{3}\)|\d{3})[-.\s]?\d{3}[-.\s]?\d{4}$/
console.log(phone.test('(555) 123-4567'))  // true
console.log(phone.test('555-123-4567'))    // true

// Username (alphanumeric, 3-16 chars)
const username = /^[a-zA-Z0-9_]{3,16}$/
console.log(username.test('john_doe123'))  // true

Both create a regex object, but they differ in when to use them:

- **Literal `/pattern/`** — Use for static patterns known at write time. The pattern is compiled when the script loads.
- **`new RegExp('pattern')`** — Use for dynamic patterns built at runtime (e.g., from user input). Remember to escape backslashes: `new RegExp('\\d+')`.

```javascript
// Static pattern - use literal
const digits = /\d+/

// Dynamic pattern - use constructor
const searchTerm = 'hello'
const dynamic = new RegExp(searchTerm, 'gi')
```

`\b` matches a **word boundary** — the position between a word character (`\w`) and a non-word character. It doesn't match any actual character; it matches a position.

```javascript
// \b prevents partial matches
console.log(/\bcat\b/.test('cat'))       // true
console.log(/\bcat\b/.test('category'))  // false
console.log(/\bcat\b/.test('the cat'))   // true
```

Word boundaries are useful when you want to match whole words only.

Add a `?` after the quantifier to make it lazy (non-greedy):

- `*?` — Match 0 or more, as few as possible
- `+?` — Match 1 or more, as few as possible
- `??` — Match 0 or 1, preferring 0
- `{n,m}?` — Match between n and m, as few as possible

```javascript
const text = '<b>bold</b> and <b>more bold</b>'

// Greedy: matches everything between first <b> and last </b>
text.match(/<b>.*<\/b>/)[0]   // "<b>bold</b> and <b>more bold</b>"

// Lazy: matches just the first <b>...</b>
text.match(/<b>.*?<\/b>/)[0]  // "<b>bold</b>"
```

- **Without `g`**: Returns first match with full details (captured groups, index, input)
- **With `g`**: Returns array of all matches (just the matched strings, no details)

```javascript
const text = 'cat and cat'

// Without g: detailed info about first match
text.match(/cat/)
// ["cat", index: 0, input: "cat and cat"]

// With g: all matches, no details
text.match(/cat/g)
// ["cat", "cat"]
```

Use `matchAll()` if you need both all matches AND details for each.

Use `$1`, `$2`, etc. for numbered groups, or `$<name>` for named groups:

```javascript
// Numbered groups
'John Smith'.replace(/(\w+) (\w+)/, '$2, $1')
// "Smith, John"

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

// $& references the entire match
'hello'.replace(/\w+/, '[$&]')
// "[hello]"
```

Escape special characters with a backslash `\`. Characters that need escaping: `. * + ? ^ $ { } [ ] \ | ( )` and `/` in literal syntax

```javascript
// Match a literal period
/\./.test('file.txt')       // true
/\./.test('filetxt')        // false

// Match a literal dollar sign
/\$\d+/.test('$100')        // true

// When using RegExp constructor, double-escape
new RegExp('\\d+\\.\\d+')   // matches "3.14"
```

For dynamic patterns from user input, escape all special chars:

```javascript
function escapeRegex(string) {
  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
}

const userInput = 'hello.world'
const pattern = new RegExp(escapeRegex(userInput))
pattern.test('hello.world')  // true
pattern.test('helloXworld')  // false
```