PowerShell add or remove elements from an Array
This is a question I get rather frequently so I thought to write an article about it. As the title implies I will show how you can add or remove elements to a PowerShell array once it has been created.
Let’s start with the definition of an array as it comes from PowerShell documentation:
An array is a data structure that is designed to store a collection of items. The items can be the same type or different types. Beginning in Windows PowerShell 3.0, a collection of zero or one object has some properties of arrays.
Creating an array in PowerShell is really simple and most probably you already did when, for example, getting a list of users from Active Directory
$adUsers = Get-AdUser -Filter '*' -Server $adDomainController
The above will return an array of AD objects containing all users matching the used filter.
Of course you can initialise an empty array with the following syntax
$myArray = @() # Specify object type [array]$myArray = @()
The above will initialise an empty array that we can, for example, fill with an AD query or adding static elements like this
$myArray = (1,2,3,4,5)
The above will add elements 1 to 5 to myArray object instantiating a new object with length of 5
PowerShell Add Elements to an Array
We have see how to create and assign values to an array but what if we want to add a sixth element to myArray? If you try the following
It will fail with the following exception
Exception calling "Add" with "1" argument(s): "Collection was of a fixed size." At line:1 char:1 + $myArray.Add(6) + ~~~~~~~~~~~~~~~ + CategoryInfo : NotSpecified: (:) , MethodInvocationException + FullyQualifiedErrorId : NotSupportedException
The above exception is thrown as a PowerShell array is a collection of fixed size and error is telling just that, it cannot be extended.
One common solution is to use the += operator like for example
$myArray += 6 # Print array's length $myArray.length 6
When using the += operator what happens under the hood is
- PowerShell creates a new array with the same elements as the old one plus the new item
- PowerShell will overwrite existing array with the new content
All of this is transparent to the user so you won’t see any difference.
Add Elements to an Array - Enter ArrayList
If you want to avoid all the copying/moving data you can instantiate myArray as a ArrayList which is dynamic and will allow you to add remove elements on the fly
# Initialize object $myArrayList = New-Object System.Collections.ArrayList($null) # Add elements to list [void]($myArrayList.Add(1)) [void]($myArrayList.Add(2)) # Print array length 2
Similarly you can remove elements from an ArrayList like this
# Will corresponding item by index $myArrayList.RemoveAt(1)
Note: Remove method will accept element’s value so 1 in the above example refers to the value not the item’s index.
Cast to [void] to suppress Add method printing new array’s length
Create Array List the alternate way
The above example will call the New-Object method to instantiate a new ArrayList but this is relatively expensive in terms of computing resources so the above can be rewritten as
[System.Collections.ArrayList]$myArray = @()
In addition of being shorter it has the added benefit of avoiding the negative performance hit of New-Object and optimizing code is always a good idea especially when dealing with larger scripts.
As an alternative you can cast PowerShell Array to ArrayList
$myArray = [System.Collections.ArrayList]@()
When writing code, despite not being required by PowerShell, I try to alway declare the object’s type as that is helpful to know, at any given moment, Properties and Methods supported by the object so I alway write
[string]$myString = 'Some Text'
$myString = 'Some Text'
This is not required by PowerShell but I find it helps code’s readability and simplifies working with an object declared 800/900 lines up in the code without having to jump back to variable’s declaration.