Check if Array Contains Element in PowerShell

1. Overview

In this article, we will see different ways to check if array contains element in PowerShell using -contains operator, Contains() method, Where-Object cmdlet, -in operator, indexOf() method, and LINQ.

2. Introduction to Problem Statement

We are given an array and element. Our goal is to check if array contains the element.

For instance, given an array [PowerShell", "Java", "PHP"], we want to check if the string "Java" is an element of this array. This simple query opens up a range of important considerations such as case sensitivity and the ability to handle different data types.

3. Using -Contains Operator

The -contains operator performs a linear search through the array and returns $true if the element is found, $false otherwise. It is most straightforward and simple way to do it.

Let’s see -Contains operator with the help of example:

This operator is case-insensitive, which means Java, JAVA, and java are the same values.

Inside the if-else block, we used the Write-Hostcmdlet to print the customized message on the PowerShell console to let the user know if their specified match is found in the $array.

4. Using -in Operator

The in operator, introduced in PowerShell v3.0, is an alternative syntax to -contains.

This operation returns $true if element is in $array. It’s syntactically different but functionally similar to -contains.

As this is similar to -contains operator, it is also case-insensitive, which means Java, JAVA, and java are the same values.

5. Using the IndexOf() Method with -ne Operator

The indexOf() method returns an index of the element if it exists. If specified element’s index is not -1, then it is in the array.

Let’s see with help of example:

So here, the IndexOf() method takes a value and returns its index in the $array; it returns -1 if the specified element is not found.

This approach is case-sensitive means PHP and php are two different elements.

6. Using .Contains() Method

Another way to check for the presence of an element is using the .Contains() method. .Contains() method checks whether element exists in array or not.

Here, we used the .Contains() method, which does the same as the -Contains operator and determines if the $element exists in the $array, but it is case-sensitive.

Further reading:

Compare Arrays in PowerShell

Read more →

Check if Array is empty in PowerShell

Read more →

7. Using Where-Object Cmdlet with Script Block

The Where-Object cmdlet offers a more flexible way to search arrays. It is case-insensitive by default. We can use -ceq operator for case-sensitive search.

Let’s understand more about $array | Where-Object {$_ -eq $element}:

• $array: This is the input array. It contains the elements that we want to check against the $element.
• |: The pipe operator in PowerShell passes the output of one command as input to another command. Here, it passes each element of $array to the Where-Object cmdlet.
• Where-Object: It’s a cmdlet used for filtering objects. It processes each object passed to it from the pipeline (in this case, each element of $array).
• { $_ -eq $element }: This is the script block that defines the condition for filtering.
  • $_: This is a special variable in PowerShell that represents the current object in the pipeline. When used inside the script block of Where-Object, it refers to each element of $array as it’s processed.
  • -eq: This is the equality operator in PowerShell. It checks if the left-hand side (each element in $array) is equal to the right-hand side ($element).
• The if Condition: The if statement evaluates the output of the Where-Object cmdlet. If Where-Object finds any elements in $array that match $element, it returns those elements, and the if condition is considered $true. If no elements match, the if condition is $false.

8. Using LINQ

LINQ queries offer powerful and efficient ways to work with collections in PowerShell.

This method returns $true if the element is found in array. LINQ queries are known for their performance and are particularly useful for large data sets. It might be overhead to use it for small dataset.

9. Check if Element Starts with Substring in Array

We can use the -like operator to check if an array contains an element having a particular pattern.

Here is an example:

10. Custom Comparisons for Complex Object

When dealing with complex object, we might need to perform custom operations such as comparing the array based on property of PSCustomObject.

This script checks for an object with a specific Name property value in an array of custom objects.

11. Working with Different Data Types in Arrays

In PowerShell, an array is a data structure that can hold a collection of items. Unlike some programming languages that require all elements in an array to be of the same type, PowerShell arrays are versatile and can contain a mix of data types.

Example of mixed array:

We can use -contains operator, .Contains() method or Where-Object cmdlet. These will work similar to what we have already discussed.

Please note that while checking if array contains any element, it also check for its datatype.

Here, $result will be $false because "42" (string) is not the same type as 42 (integer).

If we change 42 to integer, it will return $true.

Here, $result will be $true now.

12. Conclusion

Throughout this article, we have explored a variety of methods to check if an array in PowerShell contains a specific element.

These methods range from the straightforward -contains and -in operators to the more complex Where-Object cmdlet and LINQ queries. Each method has its unique characteristics and best use cases.

The simplicity of the -contains and -in operators makes them ideal for quick checks and is particularly useful for their case-insensitive nature. For more precise, case-sensitive checks, the .Contains() method and indexOf() offer a direct approach, with the latter providing additional information about the element’s position in the array.