PowerShell, a versatile and powerful scripting language developed by Microsoft, provides a wide range of functionalities for automating tasks and managing system configurations. One of the key features that make PowerShell so robust is its support for regular expressions, commonly known as regex. Regex allows developers to perform advanced string manipulations, pattern matching, and text parsing operations within PowerShell scripts. In this article, we will delve into the significance of using regex in PowerShell, exploring its benefits and practical applications.
Regular expressions, often abbreviated as regex, are a sequence of characters that form a search pattern. By utilizing regex, developers can create powerful patterns to search, replace, and manipulate text in a flexible and efficient manner. PowerShell integrates regex as part of its scripting capabilities, enabling users to harness the full potential of regex within their scripts. Let's dive deeper into the key advantages of using regex in PowerShell.
Regex empowers developers to match specific patterns within strings, allowing them to find and extract data with precision. PowerShell's integration with regex makes it a valuable tool for text processing tasks such as data validation, log file analysis, and content extraction. By defining regex patterns, developers can quickly identify relevant information within a large volume of text, saving time and effort.
Regex also enables powerful string manipulation operations within PowerShell scripts. With regex, developers can perform complex string transformations, including substitutions, character manipulations, and formatting. This capability is particularly useful when working with structured data that requires specific formatting or when modifying text to adhere to specific conventions.
Regex plays a crucial role in input validation, ensuring that user-provided data adheres to predefined formats or constraints. By defining regex patterns, PowerShell scripts can enforce data validation rules, preventing the execution of potentially harmful or incorrect commands. Whether it's validating email addresses, phone numbers, or other specific data formats, regex offers a robust mechanism for ensuring data integrity.
Regex is invaluable when it comes to filtering and extracting data from various sources, such as log files or database queries. PowerShell scripts can leverage regex patterns to parse through large datasets and extract specific information based on defined criteria. This capability is particularly useful in scenarios where data needs to be filtered or transformed before further processing or analysis.
Now that we understand the advantages of using regex in PowerShell, let's explore some practical scenarios where regex can significantly enhance script functionality and efficiency.
Regex enables PowerShell scripts to perform advanced search and replace operations within text. For example, suppose you have a script that needs to replace all occurrences of a specific word or phrase with another value. Regex patterns can facilitate this task, allowing you to find and replace text patterns efficiently.
When working with log files, regex can be immensely helpful in extracting relevant information. PowerShell scripts can utilize regex patterns to parse log files, extract error messages, timestamps, or any other desired data points. By using regex, log analysis becomes more streamlined and efficient, aiding in troubleshooting and identifying patterns or anomalies.
Regex can be used to extract specific data from unstructured or semi-structured text. Suppose you have a PowerShell script that needs to extract email addresses from a text file. By defining a regex pattern that matches valid email addresses, the script can extract all instances of email addresses, providing valuable data for further processing or analysis.
When building PowerShell scripts that require user input, regex can enforce specific formatting rules. For example, if a script expects a date input in the format "YYYY-MM-DD," a regex pattern can be defined to validate the input and ensure it matches the desired format. This prevents errors and ensures consistency in data input, improving the overall reliability of the script.
Regex can be a powerful tool for manipulating and formatting text within PowerShell scripts. For instance, if you have a script that needs to capitalize the first letter of each word in a sentence, regex can assist in achieving this task efficiently. By defining a regex pattern that identifies word boundaries and capturing the first letter of each word, the script can apply the necessary transformations, resulting in the desired formatted output.
Regex plays a vital role in pattern matching and conditional logic within PowerShell scripts. By using regex patterns, scripts can identify specific patterns or structures within text and execute conditional operations accordingly. This can be helpful in scenarios such as parsing configuration files, where different actions need to be taken based on the presence or absence of certain patterns.
The point of using regex in PowerShell is to enhance text processing capabilities, enabling advanced pattern matching, string manipulation, data validation, and extraction operations within scripts.
Yes, regex is supported in all versions of PowerShell, including PowerShell 7 and later.
Regex can be resource-intensive, especially when applied to large datasets. It is essential to optimize regex patterns and consider the performance impact when working with substantial amounts of data.
Absolutely! PowerShell provides a range of string manipulation functions, and regex can be seamlessly integrated with these functions to achieve more complex text processing tasks.
Yes, there are numerous online tutorials, documentation, and community forums dedicated to PowerShell and regex. Microsoft's official PowerShell documentation is an excellent starting point for learning more about regex in PowerShell. We may be biased, but this highly rated Udemy course is the best way to learn Regex.
While regex is primarily designed for text processing, it can also be utilized for certain non-textual data processing scenarios, such as pattern matching within numerical or binary data.
Suppose you have a log file that contains lines with server names embedded in them, such as "Error occurred on Server01 at 10:30 AM." You can use regex to extract the server names from the log file. Here's an example:
$logContent = Get-Content -Path "C:\Logs\error.log"
$pattern = "Error occurred on (\w+) at"
$serverNames = $logContent | Select-String -Pattern $pattern | ForEach-Object { $_.Matches.Groups[1].Value }
In this example, the regex pattern "Error occurred on (\w+) at" captures the server names after the "Error occurred on" phrase and before the "at" keyword. The extracted server names are stored in the $serverNames variable.
As a Windows server admin, you may need to validate Active Directory usernames to ensure they meet specific criteria. Let's say you want to validate usernames that consist of lowercase letters, numbers, and have a length between 6 and 10 characters. Here's an example:
$usernames = "john123", "admin$", "johndoe456", "user@123"
$pattern = "^[a-z0-9]{6,10}$"
foreach ($username in $usernames) {
if ($username -match $pattern) {
Write-Host "$username is a valid username."
} else {
Write-Host "$username is an invalid username."
}
}
In this example, the regex pattern "^[a-z0-9]{6,10}$" checks if the username matches the criteria of consisting of lowercase letters and numbers, with a length between 6 and 10 characters.
Windows server admins often deal with event logs and may need to filter specific entries based on event IDs or descriptions. Regex can help in such scenarios. Here's an example:
$eventLog = Get-EventLog -LogName System
$pattern = "Error|Warning"
$filteredEntries = $eventLog | Where-Object { $_.Message -match $pattern }
In this example, the regex pattern "Error|Warning" filters the event log entries that contain either "Error" or "Warning" in their message. The filtered entries are stored in the $filteredEntries variable for further analysis or action.
Certainly! Here are a few more examples of using regex in PowerShell for Windows server admins:
If you have firewall rules that include IP addresses, you can use regex to extract and manipulate them. Let's say you have a list of firewall rules stored in a text file, and you want to extract the source IP addresses from each rule. Here's an example:
$rules = Get-Content -Path "C:\Firewall\rules.txt"
$pattern = "Source: (\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})"
$ipAddresses = $rules | Select-String -Pattern $pattern | ForEach-Object { $_.Matches.Groups[1].Value }
In this example, the regex pattern "Source: (\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})" captures the IP addresses following the "Source:" keyword. The extracted IP addresses are stored in the $ipAddresses variable.
As a server admin, you may need to filter specific Windows service names based on patterns or keywords. Regex can help with this task. Here's an example:
$services = Get-Service
$pattern = "SQL|Exchange"
$filteredServices = $services | Where-Object { $_.Name -match $pattern }
In this example, the regex pattern "SQL|Exchange" filters the Windows services whose names contain either "SQL" or "Exchange". The filtered services are stored in the $filteredServices variable.
When working with event logs, you might need to extract timestamps for further analysis or reporting. Regex can assist in extracting and manipulating timestamps. Here's an example:
$eventLog = Get-EventLog -LogName Application
$pattern = "(\d{2}/\d{2}/\d{4} \d{2}:\d{2}:\d{2})"
$timestamps = $eventLog | Select-String -Pattern $pattern | ForEach-Object { $_.Matches.Groups[1].Value }
In this example, the regex pattern "(\d{2}/\d{2}/\d{4} \d{2}:\d{2}:\d{2})" captures the timestamps in the format "MM/dd/yyyy HH:mm:ss" from the event log entries. The extracted timestamps are stored in the $timestamps variable.
Regex is a powerful tool in the arsenal of a PowerShell developer. By incorporating regex into PowerShell scripts, developers can perform advanced text processing tasks, including pattern matching, data validation, extraction, and manipulation. Regex provides a flexible and efficient way to work with strings, significantly enhancing the functionality and efficiency of PowerShell scripts. Whether it's searching and replacing text, parsing log files, or validating user input, regex proves to be invaluable in a wide range of scenarios. So, the next time you find yourself working on a PowerShell script that involves complex text processing, remember the power and versatility of regex.
Regex, short for Regular Expression, is a powerful tool used in Python programming to search, manipulate, and validate text patterns. It provides a concise and efficient way to match specific patterns within strings. Whether you're a seasoned developer or just starting with Python, understanding the point of using regex can greatly enhance your text processing capabilities. In this article, we'll explore the benefits and practical applications of regex in Python, helping you grasp its significance in the world of programming.
Regular Expressions can be a game-changer when it comes to handling textual data. It enables you to perform advanced string operations that would otherwise be time-consuming and error-prone.
Regex allows you to express complex patterns in a concise and readable manner. It provides a wide range of metacharacters and special sequences that can be combined to match specific text patterns. Whether you're searching for email addresses, validating phone numbers, or extracting data from web pages, regex empowers you to handle intricate patterns with ease.
By utilizing regular expressions, you can perform various text manipulation tasks efficiently. Need to replace all occurrences of a word? Extract specific portions of a text? Find and remove unwanted characters? Regex has got you covered. It provides powerful string operations that enable you to transform text in ways that would be cumbersome with traditional string methods.
When dealing with unstructured or semi-structured data, regex shines in extracting relevant information. You can define patterns to capture specific data elements and extract them from text strings. This comes in handy when processing log files, extracting data from HTML/XML documents, or scraping information from web pages. Regexp simplifies the process of data extraction, allowing you to focus on the insights rather than the parsing.
Regex provides a robust mechanism for validating input data and performing error checks. Whether you're validating user input, verifying the format of data files, or ensuring adherence to specific standards, regex offers a concise way to enforce rules and patterns. It allows you to identify and handle invalid or inconsistent data efficiently.
Using pattern matching in Python can save you considerable time and effort when working with text data. Its powerful pattern matching capabilities eliminate the need for manual string processing, reducing the chances of errors and speeding up your development process. Regular expressions empowers you to automate tasks that would otherwise be tedious, allowing you to focus on more critical aspects of your projects.
Regex finds applications in various domains and scenarios, making it an invaluable tool for developers. Let's explore some common use cases where regex proves its worth:
When building web applications, validating user input is crucial to ensure data integrity and prevent security vulnerabilities. Regex enables you to validate and sanitize user input, such as email addresses, passwords, and phone numbers. With a well-crafted regex pattern, you can ensure that the entered data meets specific criteria, minimizing the risk of malformed or malicious inputs.
Before analyzing or modeling data, it's often necessary to clean and preprocess it. Regex simplifies this task by allowing you to search and replace specific patterns within text data. For example, you can remove HTML tags from web content, eliminate unwanted characters, or standardize formatting inconsistencies. By leveraging regex's power, you can prepare your data for further analysis or processing.
Regex serves as a fundamental tool for parsing and scraping text from
websites or documents. Whether you're extracting information from web pages, parsing log files, or scraping data from APIs, regex provides the means to define patterns and extract relevant data efficiently. It allows you to navigate through the structure of text documents and retrieve specific elements based on patterns and rules.
When working with large text documents or code files, text pattern matching can be invaluable for performing search and replace operations. Instead of manually searching for and replacing occurrences of a specific string, regex allows you to define patterns that match multiple instances of the desired text. This enables you to make comprehensive changes or substitutions within your text with just a few lines of code.
In web development frameworks like Django and Flask, Regular expression plays a vital role in URL routing and handling routing parameters. Regex patterns are used to define the structure and format of URLs and capture dynamic parts of the URL as parameters. This enables developers to create flexible and customizable routes that can handle various URL patterns and extract relevant information from the URLs.
In the field of natural language processing, regex can assist in various text analysis tasks. For example, you can use regex to identify specific patterns in text, such as dates, names, or email addresses. This can be helpful for tasks like information extraction, sentiment analysis, or entity recognition. Regex provides a powerful tool for processing and manipulating textual data in NLP applications.
Here are some frequently asked questions about using regex in Python:
Yes, regex is a widely supported concept and can be used with many programming languages and tools. The syntax and available features may vary slightly between different implementations, but the core principles remain the same. Python's regex module, re, offers comprehensive functionality for working with regular expressions.
While regex is a powerful tool, it does have some limitations. Extremely complex patterns can be hard to maintain and understand, and they may lead to performance issues. Additionally, regex may not always be the best choice for parsing highly structured data, such as XML or JSON, where specialized libraries or parsers may offer more efficient solutions.
Learning regex requires practice and familiarity with the syntax and concepts. We may be biased, but this highly rated Udemy course is the best way to learn Regex. Additionally, experimenting with regex patterns and attempting various challenges can significantly enhance your regex skills.
While regex is a powerful and widely used tool, there are alternative approaches for text processing in Python. These include string methods, list comprehensions, and even more specialized libraries like BeautifulSoup for HTML parsing or NLTK for natural language processing tasks. The choice of approach depends on the specific requirements and complexity of the task at hand.
Yes, regex is commonly used for data validation in Python. By defining appropriate patterns, you can enforce specific rules and constraints on user input or data files. Regex can help ensure that data adheres to predefined formats, such as email addresses, phone numbers, or credit card numbers.
In Python, you can use regular expressions (regex) by importing the re module. Here's a simple example of how to use regex to search for a pattern in a string:
import re
string = "Hello, world!"
# Search for the pattern "world" in the string
match = re.search("world", string)
# If the pattern is found, print the match object
if match:
print(match.group())
This will output "world", which is the match object returned by the re.search() function.
In this example, the re.search() function takes two arguments: the pattern to search for ("world"), and the string to search in ("Hello, world!"). The match.group() method is used to return the matched string.
Regex can be used for more complex string manipulations such as substitution, validation, and more. It is a powerful tool for text processing in Python.
Matching an email address pattern in Python
import re
email = "example@example.com"
# Use regex to match an email address pattern
match = re.search(r"[^@]+@[^@]+\.[^@]+", email)
if match:
print("Valid email address:", match.group())
else:
print("Invalid email address")
In this example, there.search()function searches for a pattern that matches an email address format. The pattern used,[^@]+@[^@]+\.[^@]+, matches any string of characters that contains an "@" symbol, followed by a domain name with at least one "." in it.
Replacing text with a regex pattern in Python
import re
text = "Hello, my name is John. Nice to meet you, John!"
# Replace all instances of "John" with "Mary"
new_text = re.sub(r"John", "Mary", text)
print(new_text)
In this example, the re.sub() function is used to replace all instances of the substring "John" with the substring "Mary". The resulting string, "Hello, my name is Mary. Nice to meet you, Mary!", is then printed to the console.
Extracting data from a string using named groups in Python
import re
data = "Name: John, Age: 35, Occupation: Engineer"
# Use named groups to extract data from the string
match = re.search(r"Name: (?P<name>\w+), Age: (?P<age>\d+), Occupation: (?P<occupation>\w+)", data)
if match:
name = match.group("name")
age = match.group("age")
occupation = match.group("occupation")
print("Name:", name)
print("Age:", age)
print("Occupation:", occupation)
In this example, the re.search() function searches for a pattern that matches a string with a specific format, containing a name, age, and occupation. The named groups (?P<name>\w+), (?P<age>\d+), and (?P<occupation>\w+) are used to extract the corresponding data from the string. The resulting data is then printed to the console.
Extracting URLs from Text
import re
text = 'Visit my website at https://www.example.com or check out http://blog.example.com'
url_pattern = r'https?://(?:www\.)?([\w-]+\.[\w.-]+)'
urls = re.findall(url_pattern, text)
print(urls)
The regular expression pattern https?://(?:www\.)?([\w-]+\.[\w.-]+) is used to extract URLs from a given text. Here's how the pattern works:
https?:// matches the literal "http://" or "https://".(?:www\.)? makes the "www." part of the URL optional.([\w-]+\.[\w.-]+) captures the domain name and top-level domain.
[\w-]+ matches one or more word characters or hyphens (for the subdomain or domain).\. matches a literal dot.[\w.-]+ matches one or more word characters, dots, or hyphens (for the domain and top-level domain).Splitting Sentences
import re
text = 'Hello! How are you? I hope everything is going well.'
sentences = re.split(r'(?<=[.!?])\s+', text)
print(sentences)
The regular expression pattern (?<=[.!?])\s+ is used to split a text into sentences. Here's how the pattern works:
(?<=[.!?]) is a positive lookbehind assertion, which matches a position that is preceded by a period, exclamation mark, or question mark.\s+ matches one or more whitespace characters. By using this pattern, the text is split wherever there is a period, exclamation mark, or question mark followed by one or more whitespace characters.Extracting Data from HTML Tags
import re
html = '<p>Python is a <strong>powerful</strong> programming language.</p>'
data_pattern = r'<[^>]+>([^<]+)</[^>]+>'
data = re.findall(data_pattern, html)
print(data)
The regular expression pattern '<[^>]+>([^<]+)</[^>]+>' is used to extract the content within HTML tags. Here's how the pattern works:
<[^>]+> matches the opening HTML tag.[^>]+ matches one or more characters that are not the closing angle bracket (>).([^<]+) captures the content within the HTML tags.[^<]+ matches one or more characters that are not the opening angle bracket (<).</[^>]+> matches the closing HTML tag.Parsing Time in 12-Hour Format
import re
time = 'The meeting is scheduled at 2:30 PM.'
time_pattern = r'(\d{1,2}):(\d{2})\s+(?:AM|PM)'
match = re.search(time_pattern, time)
if match:
hour = int(match.group(1))
minute = int(match.group(2))
print(f'The meeting time is {hour}:{minute:02}')
The regular expression pattern (\d{1,2}):(\d{2})\s+(?:AM|PM) is used to extract time in the 12-hour format from a given string. Here's how the pattern works:
(\d{1,2}) captures one or two digits representing the hour.: matches the colon separator.(\d{2}) captures two digits representing the minutes.\s+ matches one or more whitespace characters.(?:AM|PM) matches either "AM" or "PM" without capturing it.Removing HTML Tags
import re
html = '<p>Python is a <strong>powerful</strong> programming language.</p>'
cleaned_text = re.sub(r'<[^>]+>', '', html)
print(cleaned_text)
The regular expression pattern '<[^>]+>' is used to match HTML tags, and re.sub() is used to remove them from the text. Here's how it works:
<[^>]+> matches the opening and closing HTML tags.[^>]+ matches one or more characters that are not the closing angle bracket (>).re.sub() function replaces all occurrences of the pattern with an empty string, effectively removing the HTML tags from the text.Regex is a powerful tool that brings immense value to Python developers when it comes to text processing and manipulation. Its versatility, efficiency, and ability to handle complex patterns make it a valuable asset in various domains. Whether you're validating input, extracting data, performing search and replace operations, or parsing text, regex empowers you to accomplish these tasks with ease and precision.
By leveraging regex in your Python projects, you can save time, reduce errors, and unlock new possibilities for handling textual data. Its concise syntax and extensive functionality make it a valuable addition to your programming toolkit. With regex, you can tackle intricate patterns, validate data, extract information, and manipulate text efficiently.
So, the next time you encounter a text-related challenge in your Python projects, don't forget the point of using regex. It can be your go-to solution for handling complex patterns, manipulating text, and extracting valuable information. Embrace the power of regex and elevate your text processing capabilities in Python.
Remember to practice and experiment with regex to enhance your skills. There are plenty of online resources and tutorials available to help you grasp the concepts and master the art of crafting effective regex patterns. With dedication and hands-on experience, you'll become proficient in leveraging regex for various text processing needs.
Are you looking to do an advanced date matching and validation with Regular Expressions? Are you trying to make sure that your validation takes into account months with 30 and 31 days, and that pesky February who has 28 days and then every 4 years it has 29 days?!
Then this video below is for you!
https://regex101.com/r/9JIyQs/2 - Simple Example
https://www.debuggex.com/ - Regex Visualizer
https://jex.im/regulex/#!flags=&re=%5E(a%7Cb)*%3F%24 - Another Regex Visualizer
http://taming.tech/Google-Doc-Regex-Planning Thinking behind the Regex for a Date
https://regex101.com/r/YSSP9v/1 - Full Regex for date
https://regex101.com/r/YSSP9v/2 - Blank for you to start with
https://regex101.com/r/YSSP9v/3 - My completed example after demo
We break down the complexity, of using 2 different examples of how to validate months using Regex, into bite size chunks. We go through the whole process from scratch and show you the thinking in how to formulate your expressions.
One of the difficulties with working on a new expression is being able to see where you have gone wrong, and then troubleshooting the expressions. Here we use a Regex Visualiser to show you how it works. How the validation goes from 1 side of the Regular Expression and gets thrown out of each leg and is only valid in one place.
In this tutorial we start with a simple example of how to validate against date entries. The problem with this Regex is that if you are looking to reject inputs that might be incorrect like 30/Feb/2001 then this will not stop those from being entered.
(?<MM>[01]?[0-9])\/(?<DD>[0-3]?[0-9])\/(?<YYYY>[0-2][0-9][0-9][0-9])
If you look at the examples from this website https://www.regular-expressions.info/dates.html you will see that they start with this example.
^(19|20)\d\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])$
You can see their code working here https://regex101.com/r/9ec0Ko/1 This still doesn't validate for months working on different days per month or leap years. They do however continue on to validate the dates using Perl code. This is in the yyyy-mm-dd format from 1900-01-01 through 2099-12-31.
sub isvaliddate {
my $input = shift;
if ($input =~ m!^((?:19|20)\d\d)[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])$!) {
# At this point, $1 holds the year, $2 the month and $3 the day of the date entered
if ($3 == 31 and ($2 == 4 or $2 == 6 or $2 == 9 or $2 == 11)) {
return 0; # 31st of a month with 30 days
} elsif ($3 >= 30 and $2 == 2) {
return 0; # February 30th or 31st
} elsif ($2 == 2 and $3 == 29 and not ($1 % 4 == 0 and ($1 % 100 != 0 or $1 % 400 == 0))) {
return 0; # February 29th outside a leap year
} else {
return 1; # Valid date
}
} else {
return 0; # Not a date
}
}
That is fine for their example, but I want to have my validation all in one line that can be adapted for Python, PHP, PowerShell etc. so this doesn't work for me.
So we start with a very complex looking expression. If you are happy to just copy and paste then you can use this. But if you want to learn how to do this, then please watch the video.
So we start with a very complex looking expression. If you are happy to just copy and paste then you can use this. But if you want to learn how to do this, then please watch the video.
^(?:(?:31(\/|-|\.)(?:0?[13578]|1[02]|(?:Jan|Mar|May|Jul|Aug|Oct|Dec)))\1|(?:(?:29|30)(\/|-|\.)(?:0?[1,3-9]|1[0-2]|(?:Jan|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec))\2))(?:(?:1[6-9]|[2-9]\d)?\d{2})$|^(?:29(\/|-|\.)(?:0?2|(?:Feb))\3(?:(?:(?:1[6-9]|[2-9]\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00))))$|^(?:0?[1-9]|1\d|2[0-8])(\/|-|\.)(?:(?:0?[1-9]|(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep))|(?:1[0-2]|(?:Oct|Nov|Dec)))\4(?:(?:1[6-9]|[2-9]\d)?\d{2})$
Check it out here https://regex101.com/r/YSSP9v/1 We have used the UK and South African date format here of DD/MM/YYYY. You can obviously update this to the international date format of YYYY/MM/DD.
After going through the validation and showing you how to work and troubleshoot your validation, I finished on this expression, which I actually like more than my original example.
^(?<Monthswith31>31(?<s1>\/|\.|-)(0?[13578]|1[02]|(Jan|Mar|May|Jul|Aug|Oct|Dec))\g<s1>(?<Year>19[0-9][0-9]|200[0-7]))$|^(?<Monthswith29or30>(29|30)(?<s2>\/|\.|-)(0?[1,3-9]|1[0-2]|(Jan|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec))\g<s2>(?<Year2>19[0-9][0-9]|200[0-7]))$|^(?<Allmonthswith28>(0?[1-9]|1[0-9]|2[0-8])(?<s3>\/|\.|-)(0?[1-9]|1[0-2]|(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec))\g<s3>(?<Year3>19[0-9][0-9]|200[0-7]))$|^(?<FebLeapYears>29(?<s4>\/|\.|-)(0?2|Feb)\g<s4>(19([02468][048]|[13579][26])|200[04]))$
You can play and test it for yourself here https://regex101.com/r/YSSP9v/3
We have worked with 4 "legs" in this Regex. One to validate all months with 31 days, so that would be Jan, Mar, May, Jul, Aug, Oct, Dec. Then we look at all months with 29 or 30 days, so that would be Jan, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec. Then all the months with 1-28 days so that is all months. Finally, we look at leap years that would have Feb 29 in years like 1996, 2000, 2004 etc. and we play with an easy way to figure out what the year would validate against.
This video is an hour long because I take you through my logic and thinking so that you can figure out any Regex that you would like to play with.
This tutorial is a part of a Regex course on Udemy. Join us using the Udemy Coupon code on that page to get the course for the best possible price.