RegexOne

https://regexone.com
Admin
RegexOne offers interactive exercises and tutorials to help users learn regular expressions with...
Tokens:18,245
Snippets:165
Trust Score:5.7
Update:10 months ago
Show doc for...
Tokens:
Raw
### Capture Full Filename including Extension using Regex

Source: https://regexone.com/lesson/capturing_groups

This pattern captures the entire filename, including its extension, for files starting with 'IMG' followed by digits and ending with '.png'. It demonstrates basic group capturing for full string extraction.

```regex
^(IMG\d+\.png)$
```

--------------------------------

### C# Regex Replace Example

Source: https://regexone.com/references/csharp

Replaces parts of a string based on a regex pattern, demonstrating the use of captured groups in the replacement string. The input is a string with dates, and the output reorders month and day.

```csharp
// Lets try and reverse the order of the day and month in a few date  // strings. Notice how the replacement string also contains metacharacters // (the back references to the captured groups) so we use a verbatim  // string for that as well.
string pattern = @"([a-zA-Z]+) (\d+)";  // This will reorder the string inline and print:
//   24 of June, 9 of August, 12 of Dec // Remember that the first group is always the full matched text, so the  // month and day indices start from 1 instead of zero.
string replacedString = Regex.Replace("June 24, August 9, Dec 12",     pattern, @"$2 of $1");
Console.WriteLine(replacedString);
```

--------------------------------

### Capture Filename Without Extension using Regex

Source: https://regexone.com/lesson/capturing_groups

This pattern captures only the base filename part of a PNG file, excluding the '.png' extension. It starts with 'IMG', followed by digits, and then captures the part before the literal '.png'.

```regex
^(IMG\d+)\\.png$
```

--------------------------------

### Regex: Swap captured numbers using backreferences

Source: https://regexone.com/lesson/misc_meta_characters

This example demonstrates using capture groups and backreferences in a search and replace operation. It captures two sets of digits separated by a hyphen and then swaps their order in the replacement.

```regex
"(\d+)-(\d+)"
```

```regex
"\2-\1"
```

--------------------------------

### Regex: Simple catch-all pattern

Source: https://regexone.com/lesson/misc_meta_characters

A basic regular expression that matches any character (.), zero or more times (*). This is a broad pattern often used as a starting point or in sandbox exercises.

```regex
.*
```

--------------------------------

### Java: Matching a String with Pattern and Matcher

Source: https://regexone.com/references/java

This snippet demonstrates how to compile a regular expression into a `Pattern` object and use a `Matcher` to find matches within an input string. It shows how to check if a match exists, retrieve the start and end indices of the match, and extract the matched text. It requires importing `java.util.regex.*`.

```java
import java.util.regex.*;

// Lets use a regular expression to match a date string.
Pattern ptrn = Pattern.compile("([a-zA-Z]+) (\\d+)");
Matcher matcher = ptrn.matcher("June 24");

if (matcher.matches()) {
    // Indeed, the expression "([a-zA-Z]+) (\d+)" matches the date string
    // To get the indices of the match, you can read the Matcher object's
    // start and end values.
    // This will print [0, 7], since it matches at the beginning and end of the
    // string
    System.out.println("Match at index [" + matcher.start() +
         ", " + matcher.end() + ")");

    // To get the fully matched text, you can read the Matcher object's group
    // This will print "June 24"
    System.out.println("Match: " + matcher.group());
}
```

--------------------------------

### Combine OR with Character Sets and Quantifiers

Source: https://regexone.com/lesson/conditionals

This example demonstrates combining the OR operator with character sets ([]) and quantifiers (*, ?) to match complex conditional patterns. It can match variations like 'cats' or 'bats' (with optional 's'), or 'dogs' or 'hogs'. Be mindful that overly complex conditions can reduce readability.

```regex
([cb]ats*|[dh]ogs?)
```

--------------------------------

### Capture Filenames Without Extension using Regex

Source: https://regexone.com/lesson/capturing_groups

This pattern captures the filename part of PDF files, excluding the '.pdf' extension. It matches strings that start with 'file', followed by any characters until the '.pdf' extension. This is useful for extracting base filenames from a list.

```regex
^(file.+)\.pdf$
```

--------------------------------

### Understanding optional characters in Regex

Source: https://regexone.com/lesson/optional_characters

This example demonstrates the '?' metacharacter in regular expressions. The pattern 'ab?c' will match 'abc' (where 'b' is present) and 'ac' (where 'b' is absent). This highlights the ability of '?' to make the preceding character or group optional, matching zero or one instance.

```regex
ab?c
```

--------------------------------

### Match a String with preg_match() in PHP

Source: https://regexone.com/references/php

The `preg_match()` function tests if a regular expression matches a specific string. It stops after the first match, making it suitable for simple boolean checks. PHP requires patterns to start and end with the same delimiter, commonly a forward slash.

```php
<?php
// Lets use a regular expression to match a date string. Ignore // the output since we are just testing if the regex matches.
$regex = "/[a-zA-Z]+ \d+/";
if (preg_match($regex, "June 24")) {
    // Indeed, the expression "[a-zA-Z]+ \d+" matches the date string
    echo "Found a match!";
} else {
    // If preg_match() returns false, then the regex does not // match the string
    echo "The regex pattern does not match. :(";
}
?>
```

--------------------------------

### Match Full Line with Anchors

Source: https://regexone.com/lesson/line_beginning_end

This pattern uses the caret (^) to assert the start of the line and the dollar sign ($) to assert the end of the line. It ensures that the entire line strictly matches the specified sequence of characters, preventing partial matches within larger strings. This is crucial for accurate data validation and log analysis where exact line formats are required.

```regex
^Mission: successful$
```

--------------------------------

### Python: Search for a Regular Expression Match

Source: https://regexone.com/references/python

Uses `re.search()` to find the first occurrence of a pattern in a string. It returns a match object if found, otherwise `None`. The match object provides methods like `start()`, `end()`, and `group()` to extract information about the match.

```python
import re

# Example: Matching a date string
regex = r"([a-zA-Z]+) (\d+)"

if re.search(regex, "June 24"):
    match = re.search(regex, "June 24")
    print("Match at index %s, %s" % (match.start(), match.end()))
    print("Full match: %s" % (match.group(0)))
    print("Month: %s" % (match.group(1)))
    print("Day: %s" % (match.group(2)))
else:
    print("The regex pattern does not match. :(")
```

--------------------------------

### Capture Filename and Picture Number with Nested Groups (Regex)

Source: https://regexone.com/lesson/nested_groups

This regex pattern demonstrates the use of nested capture groups. It's designed to extract both a filename and a sequential picture number embedded within it, like 'IMG123.png'. The outer group captures the entire filename, while the inner group specifically captures the digits representing the picture number. This pattern assumes filenames start with 'IMG', followed by digits, and end with '.png'.

```regex
^(IMG(\d+))\.png$
```

--------------------------------

### C# Regex: Match a String

Source: https://regexone.com/references/csharp

Demonstrates how to use `Regex.Match()` in C# to test if a regular expression matches a given string. It shows how to retrieve match information like index, length, and value, and iterate through subsequent matches using `NextMatch()`.

```csharp
using System;
using System.Text.RegularExpressions;

public class RegexMatcher
{
    public static void Main(string[] args)
    {
        string pattern = @"([a-zA-Z]+) (\d+)"; // Using verbatim string literal
        string inputStr = "June 24";
        
        Match result = Regex.Match(inputStr, pattern);
        
        if (result.Success)
        {
            Console.WriteLine("Match found:");
            Console.WriteLine("  Index: [{0}, {1})", result.Index, result.Index + result.Length);
            Console.WriteLine("  Value: {0}", result.Value);
            
            // Example of iterating through subsequent matches if pattern allowed for it
            // while (result.Success)
            // {
            //     Console.WriteLine("Next Match: {0}", result.Value);
            //     result = result.NextMatch();
            // }
        }
        else
        {
            Console.WriteLine("No match found.");
        }
    }
}
```

--------------------------------

### Match Characters Not in a Set (Negated Character Set) - Regex

Source: https://regexone.com/lesson/matching_characters

This regex pattern utilizes a negated character set to match any character that is NOT in the specified group. For example, '[^drp]an' matches any three-letter word ending in 'an' but does not start with 'd', 'r', or 'p'.

```regex
[^drp]an
```

--------------------------------

### Javascript: Testing and Executing Regular Expression Matches

Source: https://regexone.com/references/javascript

Shows how to use the RegExp.test() method to check if a pattern matches a string and RegExp.exec() to retrieve detailed match information, including captured groups. The exec() method returns an array-like object with match details or null if no match is found.

```javascript
// Lets use a regular expression to match a date string.
var re = /([a-zA-Z]+) (\d+)/;

if (re.test("June 24")) {
    // Indeed, the expression "([a-zA-Z]+) (\d+)" matches the date string
    // If we want, we can instead search the string to find where the pattern
    // matches in the input string, and also get all the matches and captured
    // groups.
    var matches = re.exec("June 24");

    // This will print [0, 7), since it matches at the beginning and end of the
    // string
    var matchStart = matches.index;
    var matchEnd = matchStart + matches[0].length;
    console.log("Match at index " + matchStart + ", " + matchEnd);

    // The results contain the matched values. In particular:
    //    matches[0] always returns the fully matched string
    //    matches[1], matches[2], ... will return the capture
    //            groups in order from left to right in the input string
    // So this will print "June 24"
    console.log("Full match: " + matches[0]);
    // So this will print "June"
    console.log("Month: " + matches[1]);
    // So this will print "24"
    console.log("Day: " + matches[2]);
} else {
    // If the pattern does not match
    console.log("The regex pattern does not match. :(");
}
```

--------------------------------

### Capture Groups from Matched Strings in Java

Source: https://regexone.com/references/java

This snippet demonstrates how to compile a pattern, create a matcher, find matches in an input string, and extract captured groups. It covers iterating through matches, accessing captured groups by index, and resetting the matcher. Dependencies include Java's `java.util.regex.Pattern` and `java.util.regex.Matcher`.

```Java
String pattern = "([a-zA-Z]+) (\\d+)";
Pattern ptrn = Pattern.compile(pattern);
Matcher matcher = ptrn.matcher("June 24, August 9, Dec 12");

// This will print each of the matches and the index in the input string
// where the match was found:
//   June 24 at index [0, 7)
//   August 9 at index [9, 17)
//   Dec 12 at index [19, 25)
while (matcher.find()) {
    System.out.println(String.format("Match: %s at index [%d, %d]",
        matcher.group(), matcher.start(), matcher.end()));
}

// If we are iterating over the groups in the match again, first reset the
// matcher to start at the beginning of the input string.
matcher.reset();

// For each match, we can extract the captured information by reading the
// captured groups.
while (matcher.find()) {
    // This will print the number of captured groups in this match
    System.out.println(String.format("%d groups captured",
        matcher.groupCount()));

    // This will print the month and day of each match.  Remember that the
    // first group is always the whole matched text, so the month starts at
    // index 1 instead.
    System.out.println("Month: " + matcher.group(1) + ", Day: " +
         matcher.group(2));

    // Each group in the match also has a start and end index, which is the
    // index in the input string that the group was found.
    System.out.println(String.format("Month found at[%d, %d)",
         matcher.start(1), matcher.end(1)));
}
```

--------------------------------

### Match 'og' Excluding 'bog' - Regex

Source: https://regexone.com/lesson/excluding_characters

This regex pattern matches strings ending in 'og' but specifically excludes strings starting with 'b'. It demonstrates practical application of character exclusion.

```regex
[^b]og
```

--------------------------------

### C# Regex: Capture Groups and Multiple Matches

Source: https://regexone.com/references/csharp

Illustrates how to use `Regex.Matches()` in C# to find all occurrences of a pattern in a string and retrieve captured groups. It shows how to access the count of matches, individual match details, and data from specific capture groups.

```csharp
using System;
using System.Text.RegularExpressions;

public class RegexCapturer
{
    public static void Main(string[] args)
    {
        string pattern = @"([a-zA-Z]+) (\d+)"; // Using verbatim string literal
        string inputStr = "June 24, August 9, Dec 12";
        
        MatchCollection matches = Regex.Matches(inputStr, pattern);
        
        Console.WriteLine("{0} matches found.", matches.Count);
        
        foreach (Match match in matches)
        {
            Console.WriteLine("Match: {0} at index [{1}, {2})", 
                              match.Value, 
                              match.Index, 
                              match.Index + match.Length);
            
            GroupCollection groups = match.Groups;
            Console.WriteLine("  {0} groups captured in '{1}'", groups.Count, match.Value);
            
            // Group 0 is the entire match. Group 1 is the first capture group (Month).
            // Group 2 is the second capture group (Day).
            if (groups.Count > 2)
            {
                Console.WriteLine("  Month: {0}, Day: {1}", groups[1].Value, groups[2].Value);
                Console.WriteLine("  Month found at [{0}, {1})", groups[1].Index, groups[1].Index + groups[1].Length);
            }
        }
    }
}
```

--------------------------------

### Javascript: Literal vs Constructor RegExp Notation

Source: https://regexone.com/references/javascript

Demonstrates the equivalent ways to create a regular expression object in Javascript. The literal notation is often preferred for its conciseness and reduced need for escaping special characters.

```javascript
// Literal notation to match a string of alpha-numeric characters
var re = /\w+\d+/;

// Constructor notation of the same regular expression object
var re = new RegExp("\\w+\\d+");
```

--------------------------------

### Escaping a literal question mark in Regex

Source: https://regexone.com/lesson/optional_characters

To match a literal question mark character within a string using regular expressions, you must escape it with a preceding backslash '\?'. This is because '?' is a special metacharacter. This example shows how to correctly search for a question mark.

```regex
\?
```

--------------------------------

### Find and Replace Strings Using Regex in Java

Source: https://regexone.com/references/java

This code demonstrates how to replace substrings within a larger string using Java's `Matcher.replaceAll()` and `Matcher.replaceFirst()` methods. It shows how to use captured groups in the replacement string via backreferences (e.g., "$2 of $1"). The method resets the matcher before performing replacements. Dependencies include Java's `java.util.regex.Pattern` and `java.util.regex.Matcher`.

```Java
Pattern ptrn = Pattern.compile("([a-zA-Z]+) (\\d+)");
Matcher matcher = ptrn.matcher("June 24, August 9, Dec 12");

// This will reorder the string inline and print:
//   24 of June, 9 of August, 12 of Dec
// Remember that the first group is always the full matched text, so the
// month and day indices start from 1 instead of zero.
String replacedString = matcher.replaceAll("$2 of $1");
System.out.println(replacedString);
```

--------------------------------

### Javascript: RegExp Flags for Matching Behavior

Source: https://regexone.com/references/javascript

Illustrates how to apply flags to regular expressions in Javascript to modify matching behavior. Flags can be appended to literal notation or passed as a string to the RegExp constructor. Common flags include 'g' for global search, 'i' for case-insensitivity, 'm' for multiline matching, and 'u' for unicode support.

```javascript
// Find all matches (global matching) and using case insensitive matching
var re = /_regular expression_/gi;

// Constructor notation of the same regular expression object with the two flags
var re = new RegExp("_regular expression_", "gi");
```

--------------------------------

### Python: Find All Regular Expression Matches and Groups

Source: https://regexone.com/references/python

Demonstrates `re.findall()` for global searching, returning a list of all matches or captured groups. It also shows `re.finditer()` which returns an iterator of match objects for more detailed access to each match's position.

```python
import re

# Example: Finding all date strings
regex = r"[a-zA-Z]+ \d+"
matches = re.findall(regex, "June 24, August 9, Dec 12")
for match in matches:
    print("Full match: %s" % (match))

# Example: Capturing months from date strings
regex = r"([a-zA-Z]+) \d+"
matches = re.findall(regex, "June 24, August 9, Dec 12")
for match in matches:
    print("Match month: %s" % (match))

# Example: Using finditer to get match positions
regex = r"([a-zA-Z]+) \d+"
matches = re.finditer(regex, "June 24, August 9, Dec 12")
for match in matches:
    print("Match at index: %s, %s" % (match.start(), match.end()))
```

--------------------------------

### Capture Groups with preg_match_all() in PHP

Source: https://regexone.com/references/php

The `preg_match_all()` function performs a global search and captures all matches and groups from an input string. The results are stored in the `$matches_out` array, allowing iteration over multiple occurrences and captured subgroups.

```php
<?php
// Lets write a regular expression to extract the day of month in // a string with numerous dates
$pattern = "/[a-zA-Z]+ (\d+)/";
$input_str = "June 24, August 13, and December 30";
if (preg_match_all($pattern, $input_str, $matches_out)) {
    // $matches_out is now an Array of size equal to N+1, for N  // number of groups you are capturing in your regex, and +1 // for the substrings that matched.
    // This will print "2" because we are capturing only one group
    echo count($matches_out);

    // In addition, each value in $matches_out is another Array of  // size M, for M number of matches of the regex in the input.
    // This will print "3" for the three dates in our input string
    echo count($matches_out[0]);

    // $matches_out[0] is an Array of the matched strings from the // input string.
    // This prints an Array ("June 24", "August 13", "December 30")
    print_r($matches_out[0]);

    // $matches_out[1], $matches_out[2], etc. are Arrays filled with // the captured data in the same order as in the regex pattern.
    // This prints an Array ("24", "13", "30")
    print_r($matches_out[1]);
}
?>
```

--------------------------------

### Match lines with optional 's' in 'files'

Source: https://regexone.com/lesson/optional_characters

This regex pattern is designed to match lines indicating the number of files found, accommodating both singular ('file') and plural ('files') forms. It uses '\d+' to match one or more digits, 'files?' to optionally match the 's', and ' found\?' to match the literal string ' found?'. This pattern effectively handles the exercise's requirements.

```regex
\d+ files? found\?
```

--------------------------------

### Capture Image Filenames and Extensions

Source: https://regexone.com/problem/matching_filenames

This regex captures filenames and their extensions, specifically targeting .jpg, .png, and .gif files. It uses capture groups to separate the filename from the extension. It excludes temporary files (e.g., .jpg.tmp).

```regex
(\w+)\.(jpg|png|gif)$
```

--------------------------------

### Solve Exercise: Match Fuzzy Creatures

Source: https://regexone.com/lesson/conditionals

This solution uses the logical OR operator within a capture group to match specific strings. It correctly identifies and matches the lines containing 'cats' and 'dogs' while skipping others, demonstrating the practical application of conditional regex for selective text filtering.

```regex
I love (cats|dogs)
```

--------------------------------

### Java: Simple String Matching with Pattern.matches()

Source: https://regexone.com/references/java

This snippet shows the simplest way to check if a regular expression matches an entire input string using the static `Pattern.matches()` method. It takes the regex and the input string as arguments and returns a boolean indicating whether a match was found. This method is less informative than using `Pattern` and `Matcher` as it does not provide match indices or captured groups.

```java
boolean isMatch = Pattern.matches(String regex, String inputStr);
```

--------------------------------

### Extract log data with regex

Source: https://regexone.com/problem/extracting_log_data

This regex is designed to capture the method name, filename, and line number from an Android stack trace line. It utilizes capture groups to isolate these specific pieces of information. The pattern matches alphanumeric characters for the method, followed by a filename (including dots for packages), and digits for the line number, enclosed in parentheses.

```regex
(\w+)\((\[\w\.]+\):(\d+)\)
```

--------------------------------

### Match Sequential Characters with Ranges

Source: https://regexone.com/lesson/character_ranges

This regex pattern uses character ranges to match specific sequences. It expects an uppercase letter from A to C, followed by a lowercase letter from n to p, and finally a lowercase letter from a to c. This is useful for validating structured text or specific data formats.

```regex
[A-C][n-p][a-c]
```

--------------------------------

### Python: Find All Matches and Captured Groups with Regex

Source: https://regexone.com/references/python2

Demonstrates using `re.findall()` to find all non-overlapping matches of a pattern in a string. If capture groups are present, it returns a list of tuples containing the captured group data. `re.finditer()` is also shown, which returns an iterator of match objects for more detailed match information.

```python
import re
# Lets use a regular expression to match a few date strings.
regex = r"[a-zA-Z]+ \d+"
matches = re.findall(regex, "June 24, August 9, Dec 12")
for match in matches:
    # This will print:
    #   June 24
    #   August 9
    #   Dec 12
    print "Full match: %s" % (match) 

# To capture the specific months of each date we can use the following pattern
regex = r"([a-zA-Z]+) \d+"
matches = re.findall(regex, "June 24, August 9, Dec 12")
for match in matches:
    # This will now print:
    #   June
    #   August
    #   Dec
    print "Match month: %s" % (match) 

# If we need the exact positions of each match
regex = r"([a-zA-Z]+) \d+"
matches = re.finditer(regex, "June 24, August 9, Dec 12")
for match in matches:
    # This will now print:
    #   0 7
    #   9 17
    #   19 25
    # which corresponds with the start and end of each match in the input string
    print "Match at index: %s, %s" % (match.start(), match.end())
```

--------------------------------

### Capture Line Content Without Whitespace

Source: https://regexone.com/problem/trimming_whitespace

This regular expression captures the content of a line, effectively trimming any leading or trailing whitespace. It uses anchors (`^`, `$`), the whitespace character class (`\s`), and a capturing group (`(.*)`) to achieve this. It's useful in scenarios like log file processing or data cleaning where consistent formatting is required.

```regex
^\s*(.*)\s*$
```

--------------------------------

### Match Lines with Whitespace Between Number and Text (Regex)

Source: https://regexone.com/lesson/whitespaces

This regex pattern is designed to match lines where a digit is followed by a period, then one or more whitespace characters, and finally the text 'abc'. It specifically targets formatted lines and excludes those without intervening whitespace. It relies on the \d for digits, \. for a literal period, \s+ for one or more whitespace characters, and 'abc' for the literal text.

```regex
\d\.\s+abc
```

--------------------------------

### C# Regex: Verbatim String Literals

Source: https://regexone.com/references/csharp

Explains the advantage of using verbatim string literals (prefixed with `@`) when defining regular expressions in C#. This avoids the need for excessive backslash escaping, making patterns more readable.

```csharp
// Standard string literal requiring double backslashes for regex metacharacters
// string pattern = "\\n\\w"; 

// Verbatim string literal, backslashes are passed directly to the regex engine
string pattern = @"\n\w";

Console.WriteLine(pattern); // Output: \n\w
```

--------------------------------

### Match Multiple Alternatives with OR Operator

Source: https://regexone.com/lesson/conditionals

This pattern uses the logical OR operator (|) within a capture group to match strings containing 'milk', 'bread', or 'juice'. It's useful for defining explicit alternatives in your regular expressions, improving accuracy by limiting potential matches.

```regex
Buy more (milk|bread|juice)
```

--------------------------------

### Match Specific Characters with Character Sets - Regex

Source: https://regexone.com/lesson/matching_characters

This regex pattern uses a character set to match a single character from a defined group. It's useful for targeting specific letters within a string, like matching 'can', 'man', or 'fan' by specifying '[cmf]' to match 'c', 'm', or 'f'.

```regex
[cmf]an
```

--------------------------------

### JavaScript String Match with Regex

Source: https://regexone.com/references/javascript

Finds occurrences of a regular expression within a string. The match() method returns an array containing the full match and any captured groups, or null if no match is found. When the global flag 'g' is used, it returns an array of all matches without capture groups.

```javascript
var inputStr = "June 24";
var matches = inputStr.match(/(\w+) (\d+)/i);
console.log("Full match: " + matches[0]);
var matchStart = matches.index;
var matchEnd = matchStart + matches[0].length;
console.log("Match at index " + matchStart + ", " + matchEnd);
```

```javascript
var inputStr = "June 24, Aug 13, Nov 5";
var matches = inputStr.match(/(\w+) (\d+)/g);
for (var i = 0; i < matches.length; i++) {
    console.log(matches[i]);
}
```

--------------------------------

### Find and Replace Strings with preg_replace() in PHP

Source: https://regexone.com/references/php

The `preg_replace()` function finds substrings matching a pattern and replaces them with a specified string. It supports backreferences to captured groups (e.g., `$1`, `$2`) for complex replacements, allowing manipulation of matched text.

```php
<?php
// Lets try and reverse the order of the day and month in a date  // string. Notice how we can reference the two groups directly  // by index (ie. $1 and $2).
$regex = "/([a-zA-Z]+) (\d+)/";
$new_string = preg_replace($regex, "$2 of $1", "June 24");  // The string returned is either the same input string if the  // regex does not match, or the transformed string.
// This prints "24 of June"
 echo $new_string;
?>
```

--------------------------------

### Understanding Character Range Equivalence

Source: https://regexone.com/lesson/character_ranges

Demonstrates the equivalence of the \w metacharacter to a specific character range. The \w metacharacter matches any alphanumeric character (letters and numbers) plus the underscore. This provides a shorthand for commonly used character sets.

```regex
\w
```

```regex
[A-Za-z0-9_]
```

--------------------------------

### JavaScript String Search with Regex

Source: https://regexone.com/references/javascript

Searches a string for a specified regular expression and returns the index of the first match. If no match is found, it returns -1. This method is useful for locating the position of a pattern within a string.

```javascript
var inputStr = "There are 15 cats on the bed";
console.log(inputStr.search(/\d+/));
console.log(inputStr.search(/123/));
```

--------------------------------

### Specify character range for repetitions (Regex)

Source: https://regexone.com/lesson/repeating_characters

This pattern demonstrates using curly braces to define a range for the number of repetitions of the preceding character or group. This allows for more flexible matching than specifying an exact count.

```regex
a{1,3}
```

--------------------------------

### Compile Patterns for Performance with re.compile() in Python

Source: https://regexone.com/references/python

Compiling a regular expression pattern using `re.compile()` in Python can improve performance when matching against many strings. The compiled `re.RegexObject` offers methods like `search()`, `findall()`, and `sub()` that do not require the pattern or flags as arguments in subsequent calls. This is useful for repetitive matching or extraction tasks.

```python
import re

# Create a compiled pattern
regex = re.compile(r"(\w+) World")

# Search for a pattern and get match start/end indices
result = regex.search("Hello World is the easiest")
if result:
    print(result.start(), result.end())

# Find all matches and extract captured groups
for match in regex.findall("Hello World, Bonjour World"):
    print(match)

# Substitute using the compiled pattern
print(regex.sub(r"\1 Earth", "Hello World"))
```

--------------------------------

### Extract Email Username with Regex

Source: https://regexone.com/problem/matching_emails

This regex is designed to capture the username part of an email address. It matches alphanumeric characters and periods at the beginning of the string, stopping before the '@' or '+' symbols. While useful for demonstration, it's recommended to use built-in framework functions for robust email validation.

```regex
^([\w\.]*)
```

--------------------------------

### Match Decimal Numbers with Regex

Source: https://regexone.com/problem/matching_decimal_numbers

This regular expression is designed to match various decimal number formats, including optional negative signs, digits, thousand separators (commas), decimal points, and exponential notation. It handles numbers like 3.14529, -255.34, 128, 1.9e10, and 123,340.00. The expression uses anchors '^' and '$' to ensure the entire string matches the pattern. It accounts for optional negative signs, sequences of digits possibly interrupted by commas, and an optional fractional part that can include an exponent.

```regex
^-?\d+(,\d+)*(\.\d+(e\d+)?)$
```

--------------------------------

### Python: Find and Replace Strings with re.sub()

Source: https://regexone.com/references/python2

The `re.sub()` method in Python allows you to find and replace parts of a string using regular expressions. You can specify the number of replacements to make using the optional `count` argument. If `count` is zero or less, all occurrences are replaced. The replacement string can utilize backreferences to captured groups.

```python
import re

# Example: Reordering day and month in a date string
regex = r"([a-zA-Z]+) (\d+)"
input_str = "June 24, August 9, Dec 12"
replaced_str = re.sub(regex, r"\2 of \1", input_str)
print(replaced_str)

# Example with count argument (replace only the first instance)
print(re.sub(regex, r"\2 of \1", "June 24, August 9", count=1))
```

--------------------------------

### Alternative Whitespace Matching for Date Capture (Regex)

Source: https://regexone.com/lesson/nested_groups

This variation of the date capture regex uses '\s+' to match one or more whitespace characters between the month and the year. This provides more flexibility in capturing dates that might have multiple spaces or other whitespace characters separating the month and the year, while still using nested groups to capture the full date and the year.

```regex
(\w+\s+(\d+))
```

--------------------------------

### Match any character repeated 2 to 6 times (Regex)

Source: https://regexone.com/lesson/repeating_characters

This pattern utilizes the dot (.) metacharacter along with curly braces to match any character repeated between two and six times. It's useful for matching variable-length sequences of any character.

```regex
.{2,6}
```

--------------------------------

### Match specific number of repetitions (Regex)

Source: https://regexone.com/lesson/repeating_characters

This pattern uses curly braces to specify an exact number of repetitions for the preceding character or group. It's a fundamental way to control how many times a pattern element should occur.

```regex
waz{3,5}up
```

--------------------------------

### Capture HTML Tag Name using Regex

Source: https://regexone.com/problem/matching_html

This regex expression is designed to capture the name of an HTML tag. It uses \w+ to match one or more alphanumeric characters, effectively capturing the tag name following an opening bracket. It's a simple approach for extracting tag identifiers.

```regex
<(\w+)>
```

--------------------------------

### Regex: Match word boundary

Source: https://regexone.com/lesson/misc_meta_characters

This pattern uses \w+ to match one or more alphanumeric characters followed by a word boundary (\b). It is useful for capturing entire words.

```regex
\w+\b
```
Tokens:
Raw