Describes the operators that compare values in Windows PowerShell. (about_Comparison_Operators)
TOPICabout_Comparison_OperatorsSHORT DESCRIPTIONDescribes the operators that compare values in Windows PowerShell.LONG DESCRIPTIONComparison operators let you specify conditions for comparing values and finding values that match specified patterns. To use a comparison operator, specify the values that you want to compare together with an operator that separates these values. By default, all comparison operators are case-insensitive. To make a comparison operator case-sensitive, precede the operator name with a "c". For example, the case-sensitive version of "-eq" is "-ceq". To make the case-insensitivity explicit, precede the operator with an "i". For example, the explicitly case-insensitive version of "-eq" is "ieq". All comparison operators except the containment operators (-contains, -notcontains) and type operators (-is, -isnot) return a Boolean value when the input to the operator (the value on the left side of the operator) is a single value (a scalar). When the input is a collection of values, the containment operators and the type operators return any matching values. If there are no matches in a collection, these operators do not return anything. The containment operators and type operators always return a Boolean value. Windows PowerShell supports the following comparison operators. -eq Description: Equal to. Includes an identical value. Example: C:\PS> "abc", "def" -eq "abc" abc -ne Description: Not equal to. Includes a different value. Example: C:\PS> "abc", "def" -ne "abc" def -gt Description: Greater-than. Example: C:\PS> 8 -gt 6 True -ge Description: Greater-than or equal to. Example: C:\PS> 8 -ge 8 True -lt Description: Less-than. Example: C:\PS> 8 -lt 6 False -le Description: Less-than or equal to. Example: C:\PS> 6 -le 8 True -like Description: Match using the wildcard character (*). Example: C:\PS> "Windows PowerShell" -like "*shell" True -notlike Description: Does not match using the wildcard character (*). Example: C:\PS> "Windows PowerShell" -notlike "*shell" False -match Description: Matches a string using regular expressions. When the input is scalar, it populates the $Matches automatic variable. Example: C:\PS> "Sunday" -match "sun" True C:\PS> $matches Name Value ---- ----- 0 sun -notmatch Description: Does not match a string. Uses regular expressions. When the input is scalar, it populates the $Matches automatic variable. Example: C:\PS> "Sunday" -notmatch "sun" False C:\PS> $matches Name Value ---- ----- 0 sun -contains Description: Containment operator. Includes an identical value that is not part of a value. Always returns a Boolean value. Example: C:PS> "abc", "def" -contains "def" True -notcontains Description: Containment operator. Does not include an identical value. Always returns Boolean. Example: C:PS> "Windows", "PowerShell" -notcontains "Shell" True -replace Description: Replace operator. Changes the specified elements of a value. Example: C:\PS> "Get-Process" -replace "Get", "Stop" Stop-Process Equality Operators The equality operators (-eq, -ne) return a value of TRUE or the matches when one or more of the input values is identical to the specified pattern. The entire pattern must match an entire value. The following examples show the effect of the equal to operator: C:PS> 1,2,3 -eq 2 2 C:PS> "PowerShell" -eq "Shell" False C:PS> "Windows", "PowerShell" -eq "Shell" C:PS> C:\PS> "abc", "def", "123" -eq "def" def Containment Operators The containment operators (-contains and -notcontains) are similar to the equality operators. However, the containment operators always return a Boolean value, even when the input is a collection. Also, unlike the equality operators, the containment operators return a value as soon as they detect the first match. The equality operators evaluate all input and then return all the matches in the collection. The following examples show the effect of the -contains operator: C:PS> 1,2,3 -contains 2 True C:PS> "PowerShell" -contains "Shell" False C:PS> "Windows", "PowerShell" -contains "Shell" False C:\PS> "abc", "def", "123" -contains "def" True C:\PS> "true", "blue", "six" -contains "true" True The following example shows how the containment operators differ from the equal to operator. The containment operators return a value of TRUE on the first match. C:\PS> 1,2,3,4,5,4,3,2,1 -eq 2 2 2 C:\PS> 1,2,3,4,5,4,3,2,1 -contains 2 True In a very large collection, the -contains operator returns results quicker than the equal to operator. Match Operators The match operators (-match and -notmatch) find elements that match or do not match a specified pattern using regular expressions. The syntax is: <string[]> -match <regular-expression> <string[]> -notmatch <regular-expression> The following examples show some uses of the -match operator: C:\PS> "Windows", "PowerShell" -match ".shell" PowerShell C:\PS> (get-command get-member -syntax) -match "-view" True C:\PS> (get-command get-member -syntax) -notmatch "-path" True C:\PS> (get-content servers.txt) -match "^Server\d\d" Server01 Server02 The match operators search only in strings. They cannot search in arrays of integers or other objects. The -match and -notmatch operators populate the $Matches automatic variable when the input (the left-side argument) to the operator is a single scalar object. When the input is scalar, the -match and -notmatch operators return a Boolean value and set the value of the $Matches automatic variable to the matched components of the argument. If the input is a collection, the -match and -notmatch operators return the matching members of that collection, but the operator does not populate the $Matches variable. For example, the following command submits a collection of strings to the -match operator. The -match operator returns the items in the collection that match. It does not populate the $Matches automatic variable. C:\PS> "Sunday", "Monday", "Tuesday" -match "sun" Sunday C:\PS> $matches C:\PS> In contrast, the following command submits a single string to the -match operator. The -match operator returns a Boolean value and populates the $Matches automatic variable. C:\PS> "Sunday" -match "sun" True C:\PS> $matches Name Value ---- ----- 0 Sun The -notmatch operator populates the $Matches automatic variable when the input is scalar and the result is False, that it, when it detects a match. C:\PS> "Sunday" -notmatch "rain" True C:\PS> $matches C:\PS> C:\PS> "Sunday" -notmatch "day" False C:\PS> $matches C:\PS> Name Value ---- ----- 0 day Replace Operator The -replace operator replaces all or part of a value with the specified value using regular expressions. You can use the -replace operator for many administrative tasks, such as renaming files. For example, the following command changes the file name extensions of all .gif files to .jpg: Get-ChildItem | Rename-Item -NewName { $_ -replace '.gif$','.jpg$' } The syntax of the -replace operator is as follows, where the <original> placeholder represents the characters to be replaced, and the <substitute> placeholder represents the characters that will replace them: <input> <operator> <original>, <substitute> By default, the -replace operator is case-insensitive. To make it case sensitive, use -creplace. To make it explicitly case-insensitive, use -ireplace. Consider the following examples: C:\PS> "book" -replace "B", "C" Cook C:\PS> "book" -ireplace "B", "C" Cook C:\PS> "book" -creplace "B", "C" book Bitwise Operators Windows PowerShell supports the standard bitwise operators, including bitwise-AND (-band), and inclusive and exclusive bitwise-OR operators (-bor and -bxor). Beginning in Windows PowerShell 2.0, all bitwise operators work with 64-bit integers. Windows PowerShell supports the following bitwise operators. Operator Description Example -------- ---------------------- ------------------- -band Bitwise AND C:\PS> 10 -band 3 2 -bor Bitwise OR (inclusive) C:\PS> 10 -bor 3 11 -bxor Bitwise OR (exclusive) C:\PS> 10 -bxor 3 9 Bitwise operators act on the binary format of a value. For example, the bit structure for the number 10 is 00001010 (based on 1 byte), and the bit structure for the number 3 is 00000011. When you use a bitwise operator to compare 10 to 3, the individual bits in each byte are compared. In a bitwise AND operation, the resulting bit is set to 1 only when both input bits are 1. 00001010 (10) 00000011 ( 3) ------------------ bAND 00000010 ( 2) In a bitwise OR (inclusive) operation, the resulting bit is set to 1 when either or both input bits are 1. The resulting bit is set to 0 only when both input bits are set to 0. 00001010 (10) 00000011 ( 3) ------------------ bOR (inclusive) 00001011 (11) In a bitwise OR (exclusive) operation, the resulting bit is set to 1 only when one input bit is 1. 00001010 (10) 00000011 ( 3) ------------------ bXOR (exclusive) 00001001 ( 9) SEE ALSO about_Operators about_Regular_Expressions about_Wildcards Compare-Object C:\Windows>powershell get-help about_Continue -full
Microsoft Windows [Version 10.0.19045.3693]
Copyright (c) 2023 Microsoft Corporation.
ColorConsole [Version 3.7.1000] PowerShell 2.0-Export
