Как использовать регулярные выражения regex в power shell

Regular expressions (regex) are powerful tools for text manipulation and search. They allow you to match and search for patterns within text data, which makes it a valuable tool for data processing, searching, and replacing. Regular Expressions are widely used in programming languages, including PowerShell.

However, regex can be daunting for beginners, and even experienced developers can struggle with them. RegEx patterns can be simple or complex, depending on your needs. In this comprehensive guide, I will demystify regex in PowerShell and provide you with practical examples and best practices.

Using .Net Regex Methods in PowerShell

There are .Net RegEx methods available in PowerShell for working with regular expressions. Here are some of the most common ones:

• [regex]::Matches() Method – Returns all matches of a pattern in a string.
• [regex]::Match() Method – Returns the first match of a pattern in a string.
• [regex]::IsMatch() Method – Tests whether a string matches a pattern and returns a Boolean value.

Let’s take an example: Suppose you have a text that contains several IP addresses, and you want to find all of them.

 # Sample text containing IP addresses
$text = "The server IPs are 192.168.1.1, 10.0.0.1, and 172.16.0.1."
# Regular expression pattern for an IP address
$ipPattern = '\b\d{1,3}(\.\d{1,3}){3}\b'
# Find all matches using [regex]::Matches()
$matches = [regex]::Matches($text, $ipPattern)
# Display each IP address found
foreach ($match in $matches) { $match.Value
}

• SS64
• PowerShell
• How-to

Syntax Invoke-Expression [-command] string [CommonParameters]
Key -command string A literal string (or variable that contains a string) that is a valid PowerShell expression.

Standard Aliases for Invoke-Expression:

Invoke-Expression accepts a string and treats it as PowerShell code which allows the construction of dynamic code, this means that you have to be very careful about the string input.

You will have learned that PowerShell treats single and double quoted strings differently, with single quoted strings being interpreted literally, however will strip the quotes from completely, meaning this will work:

$a=’Hello’
PS C:\> Invoke-Expression ‘$a’
Hello

If the result of the expression is an empty array, invoke-expression will output

Some examples to demonstrate the difference between and Call:

$program = "Get-ChildItem"Invoke-Expression $program
> Directory listing…
$program = "Get-ChildItem"& $program
> Directory listing…

So far so good, they both work and appear to do the same thing, now lets add a parameter to filter the results:

$program = "Get-ChildItem *.txt"Invoke-Expression $program
> Directory listing
PS C:\> $program = "Get-ChildItem *.txt"
PS C:\> & $program
> 

So using Call fails, but this is a good failure because we generally want to be specific about which command/cmdlet is being called and which parameters are being passed to it.
The correct way to do this with Call is passing the parameter as a separate string:

$program = "Get-ChildItem"
$progfilter = "*.txt"
& $program $progfilter
> Directory listing…

Examples

Create a variable named $MyExpr and use it to store the text of an expression, then use invoke-expression to actually run the expression:

The built in help for has a bunch of other examples for running against multiple remote computers and using SSH.

“There are only two hard things in Computer Science: cache invalidation and naming things” ~ Phil Karlton

Related PowerShell Cmdlets

Information is power, and knowing how to sift through data quickly is a vital IT skill.

How to work with lookaheads and lookbehinds

In regular expressions, lookaheads and lookbehinds — collectively referred to as lookarounds — confirm characters before or after a match without including that text as part of the match.

For example, when using a regular expression to search a PowerShell script to find all variable names without matching on the dollar sign, you use a lookbehind to tell the regular expression that there must be a dollar sign in front of the string but not to include it in the match.

The lookaround syntax is straightforward:

• Positive lookahead: ()
• Negative lookahead: ()
• Positive lookbehind: ()
• Negative lookbehind: ()

This example uses a positive lookbehind, and the regular expression inside the lookbehind is . Since the dollar sign is a special character in regular expressions, you need to use a backslash for the escape, which means you want to match the literal character, not its special meaning in the context of regular expressions.

To use this on a PowerShell script, pipe its contents to the Select-String cmdlet:

How to use the operator

There’s a good reason why I wouldn’t just match on the dollar sign and skip the confusing lookbehind. One of the powerful uses for regular expressions is to replace text. Lookbehinds help control the match when using groups in a regex replace expression to rearrange data.

For example, if you wrote a script but then learned it was not ideal to use on the right side of a conditional statement, then you will need to swap from the right side to the left side of the conditional statements. You can write a regular expression to match comparisons that use on the right side on the operator:

Here’s a breakdown of the regular expression:

• — This checks for an if or while statement followed by a space or not and then an opening parenthesis. Regular expressions are case-sensitive, so this would only match on lowercase if and while statements.
• (?<exp>.*) -eq \$null — The matches any character sequence and assigns it to the named group. That is followed by the operator and then . It is complicated to write a regular expression to account for any possible expression on the left side of the conditional statement, but it would be possible via PowerShell Abstract Syntax Tree instead of a regular expression.
• — This is a positive lookahead that checks for the closing parenthesis.

Understanding the reason for lookarounds in this context requires learning how to work with the operator. You use in PowerShell to swap text based on a regular expression. You don’t have to worry about replacing the if, while or parenthesis since the lookarounds contain them. Focus on the matched conditional statements.

Next, use to exchange the conditional statements with their opposite:

The output shows the swapped conditional statements. By using lookarounds, the if statements stayed intact.

'(123)-456-7890'

'(123)-456-7890' -split '(?<=\))-'

'Hello, my name is "Anthony" and I am the author.'

Born in the ’80s and raised by his NES, Brock quickly fell in love with everything tech. With over 15 years of IT experience, Brock now enjoys the life of luxury as a renowned tech blogger and receiver of many Dundie Awards. In his free time, Brock enjoys adventuring with his wife, kids, and dogs, while dreaming of retirement.

Matching Strings

When working with regular expressions in PowerShell, the -match operator is used to check if a string matches a specified pattern. For example, if we want to determine if a string contains a valid email address, or we may want to check if the given date is in the specific format.

Here is an example of how to check if a string contains a 5-digit zip code:

"My zip is 90210" -match "\d{5}"
# Returns True

Match and extract a specific pattern:

$phone = "Call the number 123-456-7890 in case of any emergency!"
if ($phone -match "(\d{3}-\d{3}-\d{4})") { $matches[1]
}
# Returns 123-456-7890

Let’s validate an Email Address:

$email = "user@example.com"
# Simple pattern to validate an email address
$isValidEmail = $email -match '^\S+@\S+\.\S+$'
Write-Output $isValidEmail

Let’s take another example for matching a Date Format:

$dateString = "2023-04-01"
# Pattern to match a date in YYYY-MM-DD format
$isValidDate = $dateString -match '^\d{4}-\d{2}-\d{2}$'
Write-Output $isValidDate

Check if the given text contains a digit:

$text = "The price is 100 dollars."
# Check if the string contains any digits
$containsDigits = $text -match '\d'
Write-Output $containsDigits

Best Practices for Using Regex in PowerShell

Here are some best practices for using regex in PowerShell:

• Keep it simple – Use simple patterns whenever possible to avoid unnecessary complexity.
• Test your patterns – Always test your patterns on sample data to ensure they work as expected. Start small and build up to more complex patterns.
• Use comments – Use comments in your regex patterns to explain their purpose and make them more readable.
• Use anchors – Use anchors to ensure your pattern matches the intended text and doesn’t match unintended text.
• Use named groups to capture specific data within a pattern.
• Use escape characters to match special characters, such as $ or *.
• Be mindful of performance – Complex patterns can be resource-intensive, so be mindful of performance when using regex.

A regular expression is a series of characters that determine a matching pattern in text to find or replace input validation. Walk through a regex example in PowerShell.

Trying to find specific information within text or input can be a nightmare. Luckily, there is a way to simplify this process.

Regular expressions (regex) consist of a sequence of characters that collectively define a pattern that is to be matched. For example, regular expressions are commonly used as a means for validating input or for locating specific information within a long string of text. Regular expressions can also be used as a means of performing string manipulation.

Regex is not PowerShell-specific. Most modern programming languages natively support the use of regular expressions.

• An asterisk — * — is is a wildcard; it represents any individual character.
• Brackets — [] — indicate that a character must match the characters enclosed in brackets. For example, [abc] indicates that the character must be A, B or C.
• A caret symbol within brackets — [^] — works opposite from normal bracketed characters. Rather than declaring that a character must match those characters appearing in brackets, the caret indicates that a character cannot match any of the bracketed characters. If you were validating input and wanted to make sure that the letters A, B or C were not entered, you could use [^abc].

The examples of ways you can use regular expressions are simple and a little silly, but you can apply the approach as you need to.

Data extraction

In a PowerShell script, regular expressions enable you to locate and extract data. For example, you might create a script that locates specific data within a log file or one that extracts information from a webpage.

To show how you can use regular expressions for data extraction, I created a text file called SampleParagraph.txt. That text file contains my name and contact information, as well as the first few paragraphs of this article — as I would deliver it to the editor.

It’s simple to create a PowerShell script that reads a text file and looks for a string — in this case, an email address — within that file. You don’t even need to use regular expressions to accomplish such a task. You could locate a specific email address by using this command:

Select-String -Path SampleParagraph.txt -Pattern '<email address>'

If you look at Figure 1, you can see that this command has located my email address in the second line of the file.

You do not need regular expressions to locate data within a text file; they become useful in situations where you don’t know the exact text that you need to extract. I could use regex if the sample file contained an email address and I needed to find it but I didn’t know what the email address was. In that situation, using the previous command doesn’t work because there is no literal value — a specific email address — that I can search for.

Select-String -Path SampleParagraph.txt -Pattern '\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b'

As you can see, the first portion of the command is identical to what I used before. The difference is that, rather than searching for a literal value, I am searching for a pattern. Although the pattern looks cryptic, it has meaning.

The that comes at the beginning of the pattern tells PowerShell that the match should occur at a word boundary. This essentially means that any matches should happen at the beginning or end of a word.

Input validation

$Email=Read-Host "Please enter an email address"
If ($Email -Match '[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}')
{
Write-Host "This looks like an email address"
}
Else {
Write-Host "Invalid Email Address"
}

String manipulation

Just as you can use regular expressions to validate strings, you can also use them to manipulate them. There are countless uses for string manipulation. Consider how you might use string manipulation in conjunction with input validation. In some cases, if you detect invalid input, you might be able to use string manipulation to automatically correct it.

For example, my first name has a somewhat unusual spelling: Brien, rather than Brian. As you can imagine, my name gets misspelled a lot. The two most common misspellings are Brian and Brain. Here’s a simple PowerShell script that checks for these two misspellings and corrects them:

$Name=Read-Host "Please type Posey's first name"
If ($Name -Match "Br[ia][ia]n")
     {
     $Name='Brien'
     Write-Host "The name's spelling has been corrected to " $Name
     }
Else
     {
     Write-Host "The name was spelled correctly"
     }

Splitting Strings

Let’s split the date into components:

"02/05/2023" -split "/"
# Returns:
# 02
# 05
# 2023

Let’s split and keep text on both sides of the match:

"Alert: Disk full!" -split "(?<=: )"
# Returns:
# Alert:
# Disk full!

Another example of splitting:

$string = "word1, word2;word3.word4"
# Splitting on non-word characters
$words = $string -split "\W+"
Write-Output $words
#Output:
Word1
Word2
Word3
Word4

Here is another example:

$string = "123abc456def789"
# Splitting on digits
$parts = $string -split "(\d+)"
Write-Output $parts
#Output:
123
abc
456
def
789

Replacing Strings

Regular expressions offer a wide range of possibilities for string manipulation in PowerShell. By understanding their syntax and applying them appropriately, we can perform complex pattern matching and transformation operations with ease.

Let’s replace all repeated whitespace with an underscore:

"test file 001" -replace "\s+","_"
# Returns: "test_file_001"

Another example, to mask the Email ID in the given text and replace it with *

"The Email ID of the user is: jdoe@email.com" -replace "\S+@\S+\.\S+","**********"
#Output: The Email ID of the user is: **********

Suppose you have a string containing dates in the format MM/dd/yyyy, and you want to change them to the format yyyy-MM-dd. Here’s how you can do it:

# Original string with dates in MM/dd/yyyy format
$text = "The event is scheduled on 04/25/2023 and ends on 04/30/2023."
# Regular expression pattern to match the date format
$pattern = "(\d{2})/(\d{2})/(\d{4})"
# Replacement pattern to convert dates to yyyy-MM-dd format
$replacement = '$3-$1-$2'
# Using -replace to transform the dates in the string
$updatedText = $text -replace $pattern, $replacement
# Display the updated string
Write-Output $updatedText

(Get-Content file.txt) -replace "cat", "dog" | Set-Content file.txt

The -replace operator replaces all instances of “cat” with “dog” in the text file. The (Get-Content file.txt) command reads the file, and the Set-Content file.txt command writes the modified content back to the file.

Using Select-String with RegEx in PowerShell

Now that we’ve covered some basic regex patterns and examples, let’s see how we can use regex to match text in PowerShell. The most common PowerShell cmdlet for regex matching is Select-String. This cmdlet searches for a pattern in a file or input object and returns matching lines.

Extract Emails from Text

Here’s an example of using Select-String to find the match as per the given pattern:

$Text = "Contact me at john@email.com or jane@email.com"
# Regular expression pattern for an email address
$emailPattern = '\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b'
# Use Select-String to extract email addresses
$matches = $text | Select-String -Pattern $emailPattern -AllMatches
# Display the matched email addresses
$matches.Matches | ForEach-Object { $_.Value }

• $text contains the sample text from which you want to extract email addresses.
• $emailPattern is the regular expression pattern that matches email addresses.
• Select-String is used to search the text for matches. The -AllMatches parameter ensures that all occurrences are found.
• Finally, the script iterates over each match found and extracts the email address using $_.Value.

This will output each email address found in the text.

The Select-String cmdlet can also search in text files for given patterns. For This, let’s pass files to Select-String and search for a pattern matching social security numbers.

# Search files for social security numbers formatted as 123-45-6789
Get-ChildItem C:\Docs\*.txt | Select-String -Pattern "\d{3}-\d{2}-\d{4}"
# Output
Docs\employees.txt:123-45-6789
Docs\customers.txt:987-65-4321

Here is another example of Extracting URLs from the text:

$text = "Visit https://www.example.com and http://www.example.org for more information"
$pattern = "https?://(?:www\.)?[\w-]+\.[\w]{2,}"
$urls = $text | Select-String -Pattern $pattern -AllMatches | ForEach-Object { $_.Matches.Value }
Write-Output "URLs: $urls"

Common RegEx Patterns and Examples

Here is a quick summary of common regular expressions and examples:

Table of contents

A regular expression is a sequence of characters that define a search pattern. They allow us to search for specific patterns within a string, split strings into substrings based on a defined pattern, and replace parts of a string with new values. In PowerShell, regular expressions are implemented through the use of the -match, -replace, and -split operators, as well as the Select-String cmdlet. Let’s explore some common scenarios where regular expressions can be useful.

PowerShell supports regular expressions through the .NET Framework’s regular expressions. It consists of metacharacters, which are special characters that have a specific meaning in regex syntax. For example, the period (.) is a metacharacter that matches any character. The asterisk (*) is another metacharacter that matches zero or more occurrences of the preceding character.

Let’s break down the syntax of a simple regex pattern:

• ^ – The caret symbol represents the start of the line.
• The quick brown fox – This is the text we want to match.
• $ – The dollar sign represents the end of the line.

In this example, the regex pattern matches the entire line that consists of “The quick brown fox”.

Understanding Regex Basics in PowerShell

Let’s explore some basic regex patterns and their usage in PowerShell.

Character Classes

Here’s an example of using character classes in PowerShell:

PS C:\> 'apple' -match '[abc]'
True
PS C:\> 'banana' -match '[abc]'
False

Quantifiers

Quantifiers specify how many times a character or group of characters can occur. For example, the quantifier + matches one or more occurrences of the preceding character or group.

Here’s an example of using quantifiers in PowerShell:

PS C:\> 'aaa' -match 'a+'
True
PS C:\> 'bbb' -match 'a+'
False

Anchors

Anchors are used to match a pattern at the beginning or end of a line. The caret symbol ^ matches the beginning of a line, and the dollar sign $ matches the end of a line.

Here’s an example of using anchors in PowerShell:

PS C:\> 'hello world' -match '^hello'
True
PS C:\> 'hello world' -match 'world$'
True

Grouping in RegEx

Grouping in regex allows you to capture submatches within a larger match. You can use parentheses to group parts of a pattern together. Here’s an example of using grouping in PowerShell:

Imagine you have a date string in the format YYYY-MM-DD, and you want to extract the year, month, and day into separate variables.

$dateString = "2023-04-01"
# Regular expression with groups for year, month, and day
$pattern = '(\d{4})-(\d{2})-(\d{2})'
if ($dateString -match $pattern) { $year = $Matches[1] $month = $Matches[2] $day = $Matches[3] "Year: $year, Month: $month, Day: $day"
} else { "No match found"
}

You can use capturing groups (parentheses) in your regex pattern to extract specific parts of a string. The captured substrings are stored in the $Matches automatic variable. For example:

$string = "John Doe"
if ($string -match "(\w+)\s(\w+)") { $firstName = $Matches[1] $lastName = $Matches[2] Write-Output "First Name: $firstName, Last Name: $lastName"
}

Similarly, we have named groups in regular expressions to make your regex patterns more readable and to extract specific parts of a match easily. In PowerShell, you can use named groups by specifying (?<name>pattern) within your regular expression, where name is the name you give to the group and pattern is the pattern you are matching.

# String with a date
$dateString = "The event is on 2023-04-01."
# Regular expression with named groups for year, month, and day
$pattern = '(?<Year>\d{4})-(?<Month>\d{2})-(?<Day>\d{2})'
# Using -match to apply the pattern
if ($dateString -match $pattern) { $year = $Matches['Year'] $month = $Matches['Month'] $day = $Matches['Day'] "Year: $year, Month: $month, Day: $day"
} else { "No match found"
}

Conclusion and Further Resources

Regex can be challenging, but it is a powerful tool for text manipulation and search. By learning the basics of regex, you can use patterns to match, extract, or replace data, which can save you time and effort when processing large amounts of data. In this comprehensive guide, we covered the basics of regex syntax, common patterns, and advanced examples. We also explored how to use regex to match and replace text in PowerShell, as well as some best practices and real-world examples. Remember, regex can be complex, so start small and build up to more complicated patterns.

Now that you have a solid understanding of regex in PowerShell, go forth and use it to your advantage!

What is Regex (Regular expressions)?

Regex (regular expressions) is a pattern-matching language used for searching, replacing, and manipulating text based on specific patterns. It allows you to define complex search patterns using a combination of characters and special symbols.

How do I use regex in PowerShell?

PowerShell supports regex through several operators and cmdlets like -match, -replace, -split, Select-String, and switch. You can use these operators along with regex patterns to perform tasks like searching for matches, replacing text, or splitting strings based on patterns.

What is the difference between -match and -like?

-match uses regex for pattern matching, which allows for complex patterns such as wildcards, character classes, and quantifiers. -like, on the other hand, uses simple wildcard matching suitable for basic patterns like * and ?.

How do I extract captured groups from a regex match in PowerShell?

Can I use named capture groups in PowerShell?

How do I split a string using Regex in PowerShell?

Use the -split operator with a regex pattern to split a string into an array based on matches of the pattern. For example: "hello world" -split "\s" # Splits the string at every whitespace character

How do you make regex case-sensitive in PowerShell?

By default, PowerShell regex is case-insensitive. To make it case-sensitive, use: -cmatch, -creplace, or -csplit instead of -match, -replace, or -split

How can I search for regex patterns in files using PowerShell?

Похожее:

Массив подстановочных знаков powershell в предложении where Как найти файл по имя в power shell Как разделить строку в power shell Соответствие всем символам между двумя запятями или между и с помощью regex powershell