{"id":2431,"date":"2013-12-13T00:01:00","date_gmt":"2013-12-13T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2013\/12\/13\/using-the-powershell-contains-operator\/"},"modified":"2013-12-13T00:01:00","modified_gmt":"2013-12-13T00:01:00","slug":"using-the-powershell-contains-operator","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/using-the-powershell-contains-operator\/","title":{"rendered":"Using the PowerShell Contains Operator"},"content":{"rendered":"

Summary<\/strong>:  Microsoft Scripting Guy, Ed Wilson, talks about using the Windows PowerShell Contains<\/strong> operator to work with arrays.<\/p>\n

Microsoft Scripting Guy, Ed Wilson, is here. Today I am happy to provide you with an excerpt from my book Windows PowerShell 3.0 Step by Step<\/a>, published by Microsoft Press.<\/p>\n

\"Image<\/a><\/p>\n

Examine contents of an array<\/h2>\n

To verify input that is received from the command line, you can use the Contains<\/strong> operator to examine the contents of an array of possible values. This following technique illustrates an array of three values that is created and stored in the variable <\/span>$noun<\/strong>. The <\/span>Contains<\/strong> operator is then used to see if the array contains “hairy-nosed wombat”. Because the <\/span>$noun<\/strong> variable does not have an array element that is equal to the string “hairy-nosed wombat,” the <\/span>Contains<\/strong> operator returns False.<\/span><\/p>\n

PS C:\\> $noun = “cat”,”dog”,”rabbit”
PS C:\\> $noun -contains “hairy-nosed wombat”
False
PS C:\\><\/p>\n

If an array contains a match, the Contains<\/strong> operator returns True, as shown here:<\/p>\n

PS C:\\> $noun = “cat”,”dog”,”rabbit”
PS C:\\> $noun -contains “rabbit”
True
PS C:\\><\/p>\n

The Contains<\/strong> operator returns True only when there is an exact match. Partial matches return False. This is shown here:<\/p>\n

PS C:\\> $noun = “cat”,”dog”,”rabbit”
PS C:\\> $noun -contains “bit”
False
PS C:\\><\/p>\n

The Contains<\/strong> operator is case insensitive. Therefore, it will return True when matched, regardless of case:<\/p>\n

PS C:\\> $noun = “cat”,”dog”,”rabbit”
PS C:\\> $noun -contains “Rabbit”
True
PS C:\\><\/p>\n

If you need to perform a case sensitive match, you can use the case sensitive version of the Contains<\/strong> operator, -ccontains<\/strong>. As shown here, it will return True only if the case of the string matches the value that is contained in the array:<\/p>\n

PS C:\\> $noun = “cat”,”dog”,”rabbit”
PS C:\\> $noun -ccontains “Rabbit”
False
PS C:\\> $noun -ccontains “rabbit”
True
PS C:\\><\/p>\n

In the Get-AllowedComputers.ps1 script, a single command-line parameter is created, which is used to hold the name of the target computer for the WMI query. The computer parameter is a string, and it receives the default value from the environmental drive. This is a good technique because it ensures that the script will have the name of the local computer, which could then be used to produce a report of the results. If you set the value of the computer parameter to LocalHost<\/strong>, you never know what computer the results belong to. This is shown here:<\/p>\n

Param([string]$computer = $env:computername)<\/p>\n

The Get-AllowedComputer<\/strong> function is used to create an array of permitted computer names and to check the value of the $computer<\/strong> variable to see if it is present. If the value of the $computer<\/strong> variable is present in the array, the Get-AllowedComputer<\/strong> function returns True. If the value is missing from the array, the Get-AllowedComputer<\/strong> function returns False.<\/p>\n

The array of computer names is created by using the Get-Content<\/strong> cmdlet to read a text file that contains a list of computer names. The text file, servers.txt, is a plain ASCII text file that has a list of computer names on individual lines, as shown in the following image:<\/p>\n

\"Image<\/a><\/p>\n

A text file of computer names is easier to maintain than a hard-coded array that is embedded into the script. In addition, the text file can be placed on in central shared folder, and it can be used by many different scripts. The Get-AllowedComputer<\/strong> function is shown here:<\/p>\n

Function Get-AllowedComputer([string]$computer)
{
 $servers = Get-Content -path c:\\fso\\servers.txt
 $servers -contains $computer
} #end Get-AllowedComputer function<\/p>\n

Because the Get-AllowedComputer<\/strong> function returns a Boolean value (True\/False) it can be used directly in an IF statement to determine if the value that is supplied for the $computer<\/strong> variable is on the permitted list. If the Get-AllowedComputer<\/strong> function returns True, the Get-WmiObject<\/strong> cmdlet is used to query for BIOS information from the target computer. This is shown here:<\/p>\n

if(Get-AllowedComputer -computer $computer)
 {
   Get-WmiObject -class Win32_Bios -Computer $computer
 }<\/p>\n

On the other hand, if the value of the $computer<\/strong> variable is not found in the $servers<\/strong> array, a string that states the computer is not an allowed computer is displayed:<\/p>\n

Else
 {
  “$computer is not an allowed computer”
 }<\/p>\n

Following is the complete Get-AllowedComputer.ps1 script:<\/p>\n

Get-AllowedComputer.ps1
<\/strong>Param([string]$computer = $env:computername)<\/p>\n

Function Get-AllowedComputer([string]$computer)
{
 $servers = Get-Content -path c:\\fso\\servers.txt
 $servers -contains $computer
} #end Get-AllowedComputer function<\/p>\n

# *** Entry point to Script ***<\/p>\n

if(Get-AllowedComputer -computer $computer)
 {
   Get-WmiObject -class Win32_Bios -Computer $computer
 }
Else
 {
  “$computer is not an allowed computer”
 }<\/p>\n

Test for properties<\/h2>\n

You are not limited to only testing for specified computer names in the Get-AllowedComputer<\/strong> function. All you need to do is add additional information to the text file, as shown in the following image:<\/p>\n

\"Image<\/a><\/p>\n

A couple of modifications to the Get-AllowedComputer.ps1 script are all that is required to turn it into the Get-AllowedComputerAndProperty.ps1 script. The first is to add an additional command line parameter to allow the user to choose which property to display:<\/p>\n

Param([string]$computer = $env:computername,[string]$property=”name”)<\/p>\n

Next, the signature to the Get-AllowedComputer<\/strong> function is changed to permit passing the Property<\/strong> name. Instead of directly returning the results of the Contains<\/strong> operator, the returned values are stored in variables. The Get-AllowedComputer<\/strong> function first checks to see if the $servers<\/strong> array contains the computer name. It then checks to see if the $servers<\/strong> array contains the Property<\/strong> name. Each of the resulting values is stored in variables. The two variables are then added together, and the result returns to the calling code. When two Boolean values are added together, only the “True and True” case is equal to True. This is shown here:<\/p>\n

PS C:\\> $true -and $false
False
PS C:\\> $true -and $true
True
PS C:\\> $false -and $false
False
PS C:\\><\/p>\n

Following is the revised Get-AllowedComputer<\/strong> function:<\/p>\n

Function Get-AllowedComputer([string]$computer, [string]$property)
{
 $servers = Get-Content -path c:\\fso\\serversAndProperties.txt
 $s = $servers -contains $computer
 $p = $servers -contains $property
 Return $s -and $p
} #end Get-AllowedComputer function<\/p>\n

The if<\/strong> statement is used to determine if both the computer<\/strong> value and the property<\/strong> value are contained in the allowed list of servers and properties. If the Get-AllowedComputer<\/strong> function returns True, the Get-WmiObject<\/strong> cmdlet is used to display the chosen property<\/strong> value from the selected computer. This is shown here:<\/p>\n

if(Get-AllowedComputer -computer $computer -property $property)
 {
   Get-WmiObject -class Win32_Bios -Computer $computer |
   Select-Object -property $property
 }<\/p>\n

If the computer<\/strong> value and the property<\/strong> value are not on the permitted list, the Get-AllowedComputerAndProperty.ps1 script displays a message that states there is a non-permitted value:<\/p>\n

Else
 {
  “Either $computer is not an allowed computer, `r`nor $property is not an allowed property”
 }<\/p>\n

The complete Get-AllowedComputerAndProperty.ps1 script is shown here:<\/p>\n

Get-AllowedComputerAndProperty.ps1
<\/strong>Param([string]$computer = $env:computername,[string]$property=”name”)<\/p>\n

Function Get-AllowedComputer([string]$computer, [string]$property)
{
 $servers = Get-Content -path c:\\fso\\serversAndProperties.txt
 $s = $servers -contains $computer
 $p = $servers -contains $property
 Return $s -and $p
} #end Get-AllowedComputer function<\/p>\n

# *** Entry point to Script ***<\/p>\n

if(Get-AllowedComputer -computer $computer -property $property)
 {
   Get-WmiObject -class Win32_Bios -Computer $computer |
   Select-Object -property $property
 }
Else
 {
  “Either $computer is not an allowed computer, `r`nor $property is not an allowed property”
 }<\/p>\n

Join me tomorrow when I will talk about more cool Windows PowerShell stuff.<\/p>\n

I invite you to follow me on Twitter<\/a> and Facebook<\/a>. If you have any questions, send email to me at scripter@microsoft.com<\/a>, or post your questions on the Official Scripting Guys Forum<\/a>. See you tomorrow. Until then, peace.<\/p>\n

Ed Wilson, Microsoft Scripting Guy<\/strong><\/p>\n","protected":false},"excerpt":{"rendered":"

Summary:  Microsoft Scripting Guy, Ed Wilson, talks about using the Windows PowerShell Contains operator to work with arrays. Microsoft Scripting Guy, Ed Wilson, is here. Today I am happy to provide you with an excerpt from my book Windows PowerShell 3.0 Step by Step, published by Microsoft Press. Examine contents of an array To verify […]<\/p>\n","protected":false},"author":596,"featured_media":87096,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[51,3,4,45],"class_list":["post-2431","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-getting-started","tag-scripting-guy","tag-scripting-techniques","tag-windows-powershell"],"acf":[],"blog_post_summary":"

Summary:  Microsoft Scripting Guy, Ed Wilson, talks about using the Windows PowerShell Contains operator to work with arrays. Microsoft Scripting Guy, Ed Wilson, is here. Today I am happy to provide you with an excerpt from my book Windows PowerShell 3.0 Step by Step, published by Microsoft Press. Examine contents of an array To verify […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/2431","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/users\/596"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/comments?post=2431"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/2431\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media\/87096"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media?parent=2431"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=2431"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=2431"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}