PowerShell Arrays

Arrays are a data structure designed to store a collection of items that can be of the same or different type. Arrays are a fundamental tool in PowerShell and chances are you already used them even without knowing.

Arrays - A collection of items

As already mentioned an array is a collection of items and can be declared like this

# Declare and assign values to an array
$myArray = 22,5,10,8,12,9,80

# Create an empty array
$myEmptyArray = @()

# Range array with elements 0 to 9
$anotherArray = 100 .. 110

An array has a length properties which we can use to get the number of elements in the array, for example $anotherArray from the previous example will have a length of 10

# Get number of elements
$anotherArray.Length

11

Accessing Elements in an Array - Index

All elements in an array have an index which is the position of the element within the array, it is important to remember that arrays are created and displayed according to the order you specified for example

# Print content
$anotherArray

100
101
102
103
104
105
106
107
108
109
110

You can access each element of an array using its index number

$anotherArray[6]

105

You probably already know or noticed this but PowerShell starts indexing an array at 0 so, in our example, the 6th element will be 105

Accessing Elements in an Array - Iteration

Another common way to access elements of an array is looping through them like this for example

foreach ($index in $anotherArray)
{
    Write-Host $index
}

# Output
100
101
102
103
104
105
106
107
108
109
110

Empty Arrays

Up to this point we have illustrated how to create and immediately assign a value to arrays PowerShell also supports creating empty arrays with the following syntax:

# Create empty array
$myEmptyarray = @()

# Display length
$myEmptyarray.Length

0

This technique is useful when you want to instantiate a new Array but don’t know the number of elements it will contain.

Here’s another example of iterating through an array that I’m sure anybody dealing with an Active Directory domain used at least once:

# Create the array
$matchingUsers = @()

# Get all enabled users
$matchingUsers = Get-AdUser -Filter * -Server 'MyDc.myDomain.com'

# Iterate throguh users
foreach ($user in $matchingUsers)
{
    # Take some action
}

Strongly Typed Arrays

PowerShell is not a strongly typed language meaning we don’t need to declare the type of data a variable contains as PowerShell will try to guess this automatically:

# PowerShell will automatically create the correct
# object type
$aString = 'This is string'
$anInt = 32

$aString.GetType()

IsPublic IsSerial Name   BaseType
-------- -------- ----   --------
True     True     String System.Object
   
$anInt.GetType()

IsPublic IsSerial Name   BaseType
-------- -------- ----   --------
True     True     Int32  System.ValueType

The same happens with arrays but we have the option to create a strongly typed array that is, an array that can contain only values of a particular type:

[int32[]]$intArray = 1300,22,4578,8000

Note: In the above example the doubt square brackets [ ] after the type int32 tell PowerShell what follows is an array.

Manipulating Arrays Elements

As closing topic let’s see how we can manipulate elements in an array like adding, removing and updating elements.

Change Elements Values in an Array

Let’s say we want to update the first element of the $anotherArray we previously created with a value of 200 this can be accomplished like this

# Update element with index 0
$anotherArray[0] = 200

$anotherArray
200
101
102
103
104
105
106
107
108
109
110

Arrays support the SetValue method to change a value syntax is as follows

# Set element with index 1 to 201
$a.SetValue(201,1) #value, index

Add Elements in an Array

Elements can be added to an array with the += notation like this

# Update element with index 0
$anotherArray += 500

$anotherArray

200
201
102
103
104
105
106
107
108
109
110
500

Note: I wrote a detailed explanation of what happens when using the above notation in my previous article Add or remove elements from an array. In a nutshell PowerShell is creating a copy of the array and copying all values and adding the one we specified.

Remove Elements in an Array

Strictly speaking, similarly to what happens with adding elements, it is not possible to delete them from an array. The trick is creating a new array that will contain only relevant elements.

Here’s an example where we are removing the last element of the $anotherArray:

# Remove last element from the $anotherArray
$removeElement = $anotherArray[0..($anotherArray.Length -2)]

200
201
102
103
104
105
106
107
108
109
110

# Create an array containing only some values
$newArray = $anotherArray[0,1,3]

200
201
103

Deleting an array

To remove array’s content but not the array itself you can simply assign a $null value to it. This will remove all data contained in the array but no the object itself

$newArray = $null

You can also use the Remove-Item cmdlet but assigning a $null value is the preferred approach as it is faster especially when dealing with large arrays.