powershell basics Flashcards

Question

What are the comparison operators available in Powershell?

Answer 1

Powershell has the following comparision operators Type: Equality Operators - eq equals - ne not equals - gt greater than - ge greater than or equal - lt less than - le less than or equal Category: Matching Operators - like Returns true when string matches wildcard pattern - notlike Returns true when string does not match wildcard pattern - match Returns true when string matches regex pattern; $matches contains matching strings - notmatch Returns true when string does not match regex pattern; $matches contains matching strings Category: Containment Operators - contains Returns true when reference value contained in a collection - notcontains Returns true when reference value not contained in a collection - in Returns true when test value contained in a collection - notin Returns true when test value not contained in a collection Category: Replacement Operators -replace Replaces a string pattern Category: Type Operators - is Returns true if both object are the same type - isnot Returns true if the objects are not the same type

Answer 2

By default, all comparison operators are case-insensitive.

Answer 3

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.

Answer 4

When the input to an operator is a scalar value, comparison operators return a Boolean value. When the input is a collection of values, the comparison operators return any matching values. If there are no matches in a collection, comparison operators do not return anything. The exceptions are the containment operators (-contains, -notcontains), the In operators (-in, -notin), and the type operators (-is, -isnot), which always return a Boolean value.

Answer 5

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. Example: -eq Description: Equal to. Includes an identical value. Example: PowerShellCopy ``` C:PS> 2 -eq 2 True C:PS> 2 -eq 3 False C:PS> 1,2,3 -eq 2 2 PS> "abc" -eq "abc" True PS> "abc" -eq "abc", "def" False PS> "abc", "def" -eq "abc" abc ``` -ne Description: Not equal to. Includes a different value. Example: PowerShellCopy ``` PS> "abc" -ne "def" True PS> "abc" -ne "abc" False PS> "abc" -ne "abc", "def" True ``` PS> "abc", "def" -ne "abc" def ``` ``` -gt Description: Greater-than. Example: PowerShellCopy ``` PS> 8 -gt 6 True PS> 7, 8, 9 -gt 8 9 ``` Note This should not to be confused with `>`, the greater-than operator in many other programming languages. In PowerShell, `>` is used for redirection. For more information, see [About\_redirection](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_redirection?view=powershell-5.1#potential-confusion-with-comparison-operators). -ge Description: Greater-than or equal to. Example: PowerShellCopy ``` PS> 8 -ge 8 True PS> 7, 8, 9 -ge 8 8 9 ``` -lt Description: Less-than. Example: PowerShellCopy ``` PS> 8 -lt 6 False PS> 7, 8, 9 -lt 8 7 ``` -le Description: Less-than or equal to. Example: PowerShellCopy ``` PS> 6 -le 8 True PS> 7, 8, 9 -le 8 7 8 ```

Answer 6

Matching Operators The like operators (`-like` and `-notlike`) find elements that match or do not match a specified pattern using wildcard expressions. The syntax is: PowerShellCopy ``` -like -notlike ``` The match operators (`-match` and `-notmatch`) find elements that match or do not match a specified pattern using regular expressions. The match 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. The syntax is: PowerShellCopy ``` -match -notmatch ``` -like Description: Match using the wildcard character (\*). Example: PowerShellCopy ``` PS> "PowerShell" -like "*shell" True PS> "PowerShell", "Server" -like "*shell" PowerShell ``` -notlike Description: Does not match using the wildcard character (\*). Example: PowerShellCopy ``` PS> "PowerShell" -notlike "*shell" False PS> "PowerShell", "Server" -notlike "*shell" Server ``` -match Description: Matches a string using regular expressions. When the input is scalar, it populates the `$Matches` automatic variable. The match operators search only in strings. They cannot search in arrays of integers or other objects. 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. PowerShellCopy ``` PS> "Sunday", "Monday", "Tuesday" -match "sun" Sunday PS> $Matches 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. The `$Matches`automatic variable is a Hashtable. If no grouping or capturing is used, only one key is populated. The `0` key represents all text that was matched. For more information about grouping and capturing using regular expressions, see [about\_Regular\_Expressions](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_regular_expressions?view=powershell-5.1). PowerShellCopy ``` PS> "Sunday" -match "sun" True PS> $Matches Name Value ---- ----- 0 Sun ``` It is important to note that the `$Matches` hashtable will only contain the first occurrence of any matching pattern. PowerShellCopy ``` PS> "Banana" -match "na" True PS> $Matches Name Value ---- ----- 0 na ``` Important The `0` key is an Integer. You can use any Hashtable method to access the value stored. PowerShellCopy ``` PS> "Good Dog" -match "Dog" True PS> $Matches[0] Dog PS> $Matches.Item(0) Dog PS> $Matches.0 Dog ``` 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. PowerShellCopy ``` PS> "Sunday" -notmatch "rain" True PS> $matches PS> PS> "Sunday" -notmatch "day" False PS> $matches Name Value ---- ----- 0 day ``` -notmatch Description: Does not match a string. Uses regular expressions. When the input is scalar, it populates the `$Matches` automatic variable. Example: PowerShellCopy ``` PS> "Sunday" -notmatch "sun" False PS> $matches Name Value ---- ----- 0 sun PS> "Sunday", "Monday" -notmatch "sun" Monday ``` ###

Answer 7

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. -contains Description: Containment operator. Tells whether a collection of reference values includes a single test value. Always returns a Boolean value. Returns TRUE only when the test value exactly matches at least one of the reference values. When the test value is a collection, the Contains operator uses reference equality. It returns TRUE only when one of the reference values is the same instance of the test value object. In a very large collection, the `-contains` operator returns results quicker than the equal to operator. Syntax: ` -contains ` Examples: PowerShellCopy ``` PS> "abc", "def" -contains "def" True PS> "Windows", "PowerShell" -contains "Shell" False #Not an exact match # Does the list of computers in $DomainServers include $ThisComputer? PS> $DomainServers -contains $thisComputer True PS> "abc", "def", "ghi" -contains "abc", "def" False PS> $a = "abc", "def" PS> "abc", "def", "ghi" -contains $a False PS> $a, "ghi" -contains $a True ``` -notcontains Description: Containment operator. Tells whether a collection of reference values includes a single test value. Always returns a Boolean value. Returns TRUE when the test value is not an exact matches for at least one of the reference values. When the test value is a collection, the NotContains operator uses reference equality. Syntax: ` -notcontains ` Examples: PowerShellCopy ``` PS> "Windows", "PowerShell" -notcontains "Shell" True #Not an exact match ``` # Get cmdlet parameters, but exclude common parameters function get-parms ($cmdlet) { $Common = "Verbose", "Debug", "WarningAction", "WarningVariable", "ErrorAction", "ErrorVariable", "OutVariable", "OutBuffer" ``` $allparms = (Get-Command $Cmdlet).parametersets | foreach {$_.Parameters} | foreach {$_.Name} | Sort-Object | Get-Unique $allparms | where {$Common -notcontains $_ } } # Find unapproved verbs in the functions in my module PS> $ApprovedVerbs = Get-Verb | foreach {$_.verb} PS> $myVerbs = Get-Command -Module MyModule | foreach {$_.verb} PS> $myVerbs | where {$ApprovedVerbs -notcontains $_} ForEach Sort Tee Where ``` -in Description: In operator. Tells whether a test value appears in a collection of reference values. Always return as Boolean value. Returns TRUE only when the test value exactly matches at least one of the reference values. When the test value is a collection, the In operator uses reference equality. It returns TRUE only when one of the reference values is the same instance of the test value object. The `-in` operator was introduced in PowerShell 3.0. Syntax: ` -in ` Examples: PowerShellCopy ``` PS> "def" -in "abc", "def" True PS> "Shell" -in "Windows", "PowerShell" False #Not an exact match PS> "Windows" -in "Windows", "PowerShell" True #An exact match PS> "Windows", "PowerShell" -in "Windows", "PowerShell", "ServerManager" False #Using reference equality PS> $a = "Windows", "PowerShell" PS> $a -in $a, "ServerManager" True #Using reference equality # Does the list of computers in $DomainServers include $ThisComputer? PS> $thisComputer -in $domainServers True ``` -notin Description: Tells whether a test value appears in a collection of reference values. Always returns a Boolean value. Returns TRUE when the test value is not an exact match for at least one of the reference values. When the test value is a collection, the In operator uses reference equality. It returns TRUE only when one of the reference values is the same instance of the test value object. The `-notin` operator was introduced in PowerShell 3.0. Syntax: ` -notin \` Examples: PowerShellCopy ``` PS> "def" -notin "abc", "def" False PS> "ghi" -notin "abc", "def" True PS> "Shell" -notin "Windows", "PowerShell" True #Not an exact match PS> "Windows" -notin "Windows", "PowerShell" False #An exact match ``` # Find unapproved verbs in the functions in my module PS> $ApprovedVerbs = Get-Verb | foreach {$_.verb} PS> $MyVerbs = Get-Command -Module MyModule | foreach {$_.verb} ``` PS> $MyVerbs | where {$_ -notin $ApprovedVerbs} ForEach Sort Tee Where ```

Answer 8

Replacement 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 .txt files to .log: PowerShellCopy ``` Get-ChildItem *.txt | Rename-Item -NewName { $_.name -replace '\.txt$','.log' } ``` The syntax of the `-replace` operator is as follows, where the placeholder represents the characters to be replaced, and the placeholder represents the characters that will replace them: ` , ` 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: PowerShellCopy ``` PS> "book" -replace "B", "C" ``` outputCopy ``` Cook ``` PowerShellCopy ``` "book" -ireplace "B", "C" ``` outputCopy ``` Cook ``` PowerShellCopy ``` "book" -creplace "B", "C" ``` outputCopy ``` book ``` It is also possible to use capturing groups, and substitutions with the `-replace` operator. For more information, see [about\_Regular\_Expressions](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_regular_expressions?view=powershell-5.1). Substitutions in Regular Expressions Additionally, capturing groups can be referenced in the string. This is done by using the $ character before the group identifier. Two of the ways to reference capturing groups is by Number and by Name * By Number - Capturing Groups are numbered from left to right. PowerShellCopy ``` "John D. Smith" -replace "(\w+) (\w+)\. (\w+)", '$1.$2.$3@contoso.com' ``` outputCopy ``` John.D.Smith@contoso.com ``` * By Name - Capturing Groups can also be referenced by name. PowerShellCopy ``` "CONTOSO\Administrator" -replace '\w+\\(?\w+)', 'FABRIKAM\${user}' ``` outputCopy ``` FABRIKOM\Administrator ``` Warning Since the `$` character is used in string expansion, you will need to use literal strings with substitution, or escape the `$` character. PowerShellCopy ``` 'Hello World' -replace '(\w+) \w+', "`$1 Universe" ``` outputCopy ``` Hello Universe ``` Additionally, sicne the `$` character is used in substitution, you will need to escape any instances in your string. PowerShellCopy ``` '5.72' -replace '(.+)', '$$$1' ``` outputCopy ``` $5.72 ```

Answer 9

Type comparison The type comparison operators (`-is` and `-isnot`) are used to determine if an object is a specific type. -is Syntax: ` -is ` Example: PowerShellCopy ``` PS> $a = 1 PS> $b = "1" PS> $a -is [int] True PS> $a -is $b.GetType() False ``` -isnot Syntax: ` -isnot ` Example: PowerShellCopy ``` PS> $a = 1 PS> $b = "1" PS> $a -isnot $b.GetType() True PS> $b -isnot [int] True ```

Answer 10

Output for first script 1,2,3,4,5,6,7,8,9 -lt 5 PS K:\\> 1,2,3,4,5,6,7,8,9 -lt 5 1 2 3 4 Output for second script $valueofnumbers=4,1,2,3,4 $valueofnumbers -lt 3 1 2 When using comparison operator -lt on an array or group of numbers seperated by comma(,) the oprerator would return the values which satisfies the condition. in the above example because we used an array or a group of numbers with the comparision operator -lt it returned all the values which were lesser than the condition.

Answer 11

**Arithmetic Operators**: +, -, \*, /, % **Assignment Operators:** =, +=, -=, \*=, /=, %= **Comparison Operators:** -eq, -ne, -gt, -lt, -le, -ge, -match, -notmatch, -replace, -like, -notlike, -in, -notin, -contains, -notcontains, -bAND, -bOR, -bXOR, -bNOT Use comparison operators (-eq, -ne, -gt, -lt, -le, -ge) to compare values and test conditions. For example, you can compare two string values to determine whether they are equal. The comparison operators also include operators that find or replace patterns in text. The (-match, -notmatch, -replace) operators use regular expressions, and (-like, -notlike) use wildcards \*. Containment comparison operators determine whether a test value appears in a reference set (-in, -notin, -contains, -notcontains). Bitwise comparison operators (-bAND, -bOR, -bXOR, -bNOT) manipulate the bit patterns in values. **Logical Operators:** -and, -or, -xor, -not, ! **Redirection Operators:** \>, \>\>, 2\>, 2\>\>, and 2\>&1 Use redirection operators (\>, \>\>, 2\>, 2\>\>, and 2\>&1) to send the output of a command or expression to a text file. The redirection operators work like the Out-File cmdlet (without parameters) but they also let you redirect error output to specified files. **Split and Join Operators:** -split, -join The -split and -join operators divide and combine substrings. The -split operator splits a string into substrings. The -join operator concatenates multiple strings into a single string. **Type Operators:** -is, -isnot, -as Use the type operators (-is, -isnot, -as) to find or change the .NET Framework type of an object. **Unary Operators:** Use unary operators to increment or decrement variables or object properties and to set integers to positive or negative numbers. For example, to increment the variable $a from 9 to 10, you type $a++. **Array subexpression** : @( ) Returns the result of one or more statements as an array. If there is only one item, the array has only one member. @(Get-WmiObject win32\_logicalDisk) **Call operator:** & Runs a command, script, or script block. The call operator, also known as the "invocation operator," lets you run commands that are stored in variables and represented by strings or script blocks. The call operator executes in a child scope. This example stores a command in a string and executes it using the call operator. $c = "get-executionpolicy" & $c The call operator does not parse strings. This means that you cannot use command parameters within a string when you use the call operator. **Cast operator** [] Converts or limits objects to the specified type. If the objects cannot be converted, PowerShell generates an error. [datetime]$birthday = "1/20/88" [int64]$a = 34 **Comma operator:** , As a binary operator, the comma creates an array. As a unary operator, the comma creates an array with one member. Place the comma before the member. ``` $myArray = 1,2,3 $SingleArray = ,1 ``` **Dot sourcing operator:**. Runs a script in the current scope so that any functions, aliases, and variables that the script creates are added to the current scope. . c:\scripts\sample.ps1 ----------------------------------------------------------- **Note:** The dot sourcing operator is followed by a space. Use the space to distinguish the dot from the dot (.) symbol that represents the current directory. ----------------------------------------------------------- **Property dereferences operator: .** Accesses the properties and methods of an object. $myProcess.peakWorkingSet (Get-Process PowerShell).kill() **Range operator:** **..** Represents the sequential integers in an integer array, given an upper, and lower boundary. 1..10 10..1 foreach ($a in 1..$max) {Write-Host $a} Beginning in PowerShell 6,the range operator works with Characters as well as Integers. To create a range of characters, enclose the boundary characters in quotes. PS\> 'a'..'f' a b c d e f **Static member operator"** **::** Calls the static properties operator and methods of a .NET Framework class. To find the static properties and methods of an object, use the Static parameter of the Get-Member cmdlet. [datetime]::now **Subexpression operator:** $( ) Returns the result of one or more statements. For a single result, returns a scalar. For multiple results, returns an array. $($x \* 23) $(Get-WmiObject win32\_Directory)

powershell basics Flashcards

(36 cards)