Skip to content
Subscribe to RSS Find me on GitHub Follow me on Twitter

Replacing Regex Groups in JavaScript


Regular expressions (regex) are powerful tools for pattern matching and manipulation in JavaScript. They allow us to search, match, and replace specific patterns within strings. One common use case is the need to replace specific groups within a regex match.

Being able to replace specific groups within a regex match is important because it allows us to modify only certain parts of a string while leaving the rest unchanged. This can be especially useful when dealing with complex data formats or when performing data transformations. By targeting and replacing specific groups, we can easily modify strings to fit our desired format or extract specific information from them.

In the following sections, we will explore how to define and use regex groups in JavaScript, as well as how to replace those groups using the replace() method. We will also provide practical examples to illustrate the usefulness of replacing regex groups in real-world scenarios.

Understanding Regex Groups

Regular expression groups are a powerful feature in JavaScript that allow you to match and capture specific parts of a string. They are defined using parentheses in the regex pattern and are used to group together multiple characters or subpatterns.

The purpose of regex groups is to capture and extract specific information from a string that matches a given pattern. By enclosing parts of the pattern in parentheses, you create distinct groups that can be referenced later.

Here is an example to illustrate the syntax for defining groups in a regex pattern:

const regex = /(ab)+/;

In this example, the (ab) is a group that matches the characters "ab". The + quantifier after the group indicates that the group should be repeated one or more times.

Groups can be used to capture specific parts of a string by accessing the match object that is returned by the match() method. The match object contains an array of captured groups, with the first element being the overall match and subsequent elements representing the captured groups in the order they appear in the pattern.

Let's consider an example to demonstrate how groups can be used to match and capture specific parts of a string:

const regex = /(\d{2})-(\d{2})-(\d{4})/;
const match = regex.exec("Today's date is 25-12-2022");

console.log(match[0]); // "25-12-2022"
console.log(match[1]); // "25"
console.log(match[2]); // "12"
console.log(match[3]); // "2022"

In this example, the regex pattern /(\d{2})-(\d{2})-(\d{4})/ matches a date in the format "dd-mm-yyyy". The three groups capture the day, month, and year respectively. By accessing the elements of the match array, we can retrieve the captured groups individually.

Understanding regex groups and how to define them is essential for utilizing their power in matching and capturing specific parts of a string. They enable you to extract valuable information from text data and perform further manipulations as needed.

Matching and Capturing Groups

In regular expressions, parentheses () are used to create capturing groups. Capturing groups allow us to match and capture specific parts of a string that match a certain pattern.

When a regular expression pattern is matched against a string, the match result is stored in a Match object. This object contains information about the overall match, as well as any capturing groups that were defined in the pattern.

The Match object has several properties that provide access to the captured groups:

  • index: The index of the matched substring within the input string.
  • input: The input string that was matched against.
  • length: The length of the matched substring.

To access the captured groups, we can use the Match object's groups property. This property returns an object containing the captured groups as properties, where each property name corresponds to the capturing group's index or name.

Let's see some examples to better understand capturing groups in action:

const regex = /(\d{2})-(\d{2})-(\d{4})/;
const match = regex.exec('Today is 12-05-2022');

console.log(match.groups); // { '0': '12-05-2022', '1': '12', '2': '05', '3': '2022' }
console.log(match.groups[1]); // '12'
console.log(match.groups[2]); // '05'
console.log(match.groups[3]); // '2022'

In this example, the regex pattern (\d{2})-(\d{2})-(\d{4}) captures a date in the format dd-mm-yyyy. The capturing groups are defined by the parentheses (). The Match object's groups property gives us access to the captured groups, allowing us to retrieve specific parts of the matched string.

Capturing groups are useful in various scenarios, such as extracting specific information from a string, validating input formats, or transforming parts of a string. They provide a powerful tool for manipulating and working with text data in JavaScript.

Replacing Regex Groups

The replace() method in JavaScript is a powerful tool for manipulating strings based on regular expressions. It allows you to replace specific groups within a regex match with new values.

The syntax for replacing specific groups in a regex match using the replace() method is as follows:

string.replace(regex, replacement);

Here, string is the original string that you want to perform the replacement on. regex is the regular expression pattern that you want to match, and replacement is the new value that you want to replace the matched groups with.

To target and replace specific parts of a matched string using regex groups, you can utilize capture groups in your regex pattern. Capture groups are created by enclosing a part of the pattern in parentheses ( ). The matched value inside the parentheses can then be referenced using backreferences.

Here's an example that demonstrates how to replace a specific group within a regex match:

const str = 'Hello, World!';
const regex = /(Hello), (World)/;
const newStr = str.replace(regex, '$2, $1');
console.log(newStr); // Output: World, Hello

In this example, the regex pattern /(Hello), (World)/ matches the string "Hello, World!". The two capture groups (Hello) and (World) capture the words "Hello" and "World", respectively.

The replacement string '$2, $1' references the captured groups using backreferences. $2 represents the second capture group (World), and $1 represents the first capture group (Hello). By swapping the order of the backreferences, the replacement string becomes "World, Hello".

The resulting string after the replacement is "World, Hello".

In this way, you can use regex groups and the replace() method to target and replace specific parts of a matched string in JavaScript. This allows for powerful string manipulation and customization based on your specific needs.

Practical Examples

In this section, we will explore some practical examples to understand how to replace regex groups in JavaScript. We will provide step-by-step walkthroughs of common scenarios where replacing regex groups is useful, along with demonstrations of the regex patterns and techniques used to achieve the desired replacements.

Example 1: Formatting Phone Numbers

Let's say we have a list of phone numbers in a specific format, but we want to convert them to a different format. For example, we have phone numbers in the format (123) 456-7890, but we want to convert them to the format 123-456-7890.

To achieve this, we can use regex groups to capture the different parts of the phone number and then replace them in the desired format. Here's an example code snippet:

const phoneNumber = "(123) 456-7890";
const formattedNumber = phoneNumber.replace(/(\()(\d{3})(\)) (\d{3})-(\d{4})/, "$2-$4-$5");

console.log(formattedNumber); // Output: 123-456-7890

In this example, we use capturing groups (\(), (\d{3}), (\)), (\d{3}), and (\d{4}) to capture the opening parenthesis, the first three digits, the closing parenthesis, the next three digits, and the last four digits of the phone number, respectively. We replace the matched string with the desired format using the backreferences $2, $4, and $5 to refer to the captured groups.

Example 2: Extracting Domain Name from URLs

Suppose we have a list of URLs, and we want to extract the domain name from each URL. For example, we have URLs like,, and We want to extract only the domain names (,, from these URLs.

To achieve this, we can use regex groups to capture the domain name and replace the rest of the URL with an empty string. Here's an example code snippet:

const urls = [

const domainNames = => url.replace(/^(https?:\/\/)?(www\.)?([^/?]+)/, "$3"));

// Output: ["", "", ""]

In this example, we use capturing groups ^(https?:\/\/)?, (www\.)?, and ([^/?]+) to capture the optional http:// or https://, the optional www., and the actual domain name, respectively. We replace the matched string with the captured domain name using the backreference $3.

Limitations and Potential Hurdles

When replacing regex groups, it is essential to carefully consider the patterns and ensure they cover all possible variations in the input data. It is also important to handle edge cases, such as empty strings or unexpected input, to avoid unexpected results.

Additionally, regex can be powerful but can also become complex and hard to maintain. It is crucial to strike a balance between using regex effectively and keeping the code readable and maintainable. Regular expressions can be challenging to debug, so it's helpful to use tools like regex testers to validate and fine-tune the patterns before implementing them in code.

Remember to test your regex patterns thoroughly with various input scenarios to ensure they produce the desired results.


In conclusion, replacing regex groups in JavaScript is a powerful tool for manipulating and transforming strings. By using regex groups, we can target specific parts of a matched string and replace them with desired values or patterns.

The importance of being able to replace regex groups lies in its ability to extract and modify specific portions of a string, which can be extremely useful in various scenarios. Whether it's extracting data from a complex text or transforming a specific format, regex groups allow us to efficiently manipulate strings to meet our needs.

Key takeaways from this article include:

  • Understanding the concept of regex groups and how they can be used to capture specific parts of a string.
  • Knowing the syntax for defining regex groups and using them in regex patterns.
  • Familiarity with the replace() method in JavaScript and its ability to replace specific groups in a regex match.
  • Recognizing the practical applications of replacing regex groups, such as data extraction and string transformation.

To further explore regex manipulation in JavaScript, it is recommended to practice using regex groups in different scenarios. Experiment with different patterns, explore the various methods and properties of the Match object, and continue to expand your knowledge of regular expressions. By mastering regex groups, you'll be equipped with a powerful tool for string manipulation in JavaScript.