Index
Introduction to PowerShell Arrays
What is an array?
Arrays are a fundamental feature in almost all programming languages, serving as a data structure that holds multiple pieces of data. When working with an array, you can either apply the same command to each item within the array or access and manipulate individual elements using their index.
Arrays are so integral to PowerShell that they are featured in every PowerShell tutorial. A solid understanding of how to work with arrays is crucial for many aspects of using PowerShell effectively.
In PowerShell, arrays can contain one or more items, which can be strings, integers, objects, or even other arrays. An array can hold any combination of these items. Each item in an array has an index, starting at 0. This means the first item in an array is indexed as 0, the second as 1, and so on.
Creating and initializing arrays
The most basic way to create and initialize an array is by simply assigning multiple values to a variable, separated by commas.
$array = 1, 2, 3, 4, 5
But there is another way to create, and initialize, an array. This way is far more common, flexible and readable. When I mention creating an array in the rest of the post, I will mean creating and initializing the array.
$array = @() ## Just creating the array and leaving it empty
$array.count ## Results in: 0
$array = @(1, 2, 3, 4, 5) ## Creating and initializing the array
$array.count ## Results in: 5
We can even split the creation over multiple lines using this notation.
$array = @(
"One",
"Two",
"Three",
"Four",
"Five"
)
And when we query the value of the variable we get the following:
One
Two
Three
Four
Five
Accessing and modifying array elements
Single or specific elements
Now that we have an array, how do we access the items inside? There are several ways to do this, the most common is using the index of the items in the array. As I mentioned earlier, the indexes start at 0. Therefore, to retrieve the first item in our array, we need to look at the item with an index of zero. We can do this by running:
$array[0]
This returns ‘One‘ because this is the first item in our array. Using $array[3] will return ‘Four‘.
Using a negative index you can return items reading the array backwards. In this notation we use as an index -1 for the last item, followed by -2 for the second last item.
$array[-1]
This returns ‘Five‘ because this is the last item in our array.
If You want to return multiple (selected) items, you can by using the following notations:
$array[1,3,4] ## Return item 1, 3 and 4 Two Four Five $array[0..2] ## Return item 0 till 2 (0, 1 and 2) One Two Three
Loop through the elements
One of the most powerful features in any command-line interface, is the ability to perform the same action on all items in an array. There are several ways to achieve this. Often the simplest way to perform repeated actions is using a pipeline, represented by the | character. When you pass an array to a pipeline, each item in the array is processed individually.
The following command takes all elements of the array at one time, and for each of the elements we encase it between “>>” and “<<” and write it to the screen.
$array | Foreach-Object { Write-host ">>$_<<" }
>>One<<
>>Two<<
>>Three<<
>>Four<<
>>Five<<
There are a couple more methodes of looping through an array. See an upcoming post “Fundamentals | Loops” for more information about the various loops in PowerShell.
Changing the value of an element
Now we know how to access specific items in an array we can use the same method to change the value of an item. Let’s say we want to change the value of ‘Three‘ into ‘3‘. Note that this is the item with index 2.
$array[2] = 3
$array
One
Two
3
Four
Five
Common array operations
Add
We now created, updated and read (specific) elements of an array. What about adding to an array? Actually you can’t. Let me explain. Once an array is created it cannot be changed in size. But there is a way around this. When we need to add to an array we create a new array and delete the old one. Sounds complicated, but PowerShell does the heavy lifting. Let’s look at an example:
$array = @(1, 2, 3) $array = $array + 6 $array 1 2 3 6 ## or the shorter notation $array += 7 $array 1 2 3 6 7
Because we are continuously creating and deleting arrays this is quite costly. In little arrays you won’t notice this, but when the arrays get larger you can feel it getting slower. There are better array types if you need to add to it. See ArrayList or Generic List for better options.
Remove
Removing items from an array can be done in several ways. The first way is by assigning the $null value to the desired location. then we filter out all $null values.
$array = @(1, 2, 3, 4, 5)
$array[2] = $Null # This sets the third element to $Null
$array = $array | Where-Object { $_ -ne $Null } # This filters out the $Null values
$array
1
2
4
5
The next way is to create a new array that excludes the item you want to remove. This might be a bit more elegant, but far more complex to read.
$array = @(1, 2, 3, 4, 5)
$indexToRemove = 2
$array = $array[0..($indexToRemove-1)] + $array[($indexToRemove+1)..($array.Length-1)]
$array
1
2
4
5
As with adding values to an array, the basic form of an array is not the best form for removing items. See ArrayList or Generic List for better options.
Sorting an array
Sorting an array is straightforward using the Sort-Object cmdlet.
$Array = @(5, 3, 8, 1, 2)
$sortedArray = $Array | Sort-Object
$sortedArray
1
2
3
5
8
To revert the order of sorting (Sort in descending order), use the -Descending parameter.
Arrays of Objects
Now we have seen and worked with arrays of single values (in the examples: String & Int), but as stated in the start of this post it also can contain objects. These are the data types we will use most often when working with arrays. Let’s see how we can work with this.
Create
Let’s say we have some object containing a user name, an age and an occupation.
@{
Name = “Bob”
Age = 25
Occupation = “System Administrator”
}
@{
Name = “Angela”
Age = 40
Occupation = “Human Resource”
}
And we want to put those objects (HashTables) into an array. It is almost the same as how we learned it with single values.
$ObjectArray = @(
@{
Name = “Bob”
Age = 25
Occupation = “System Administrator”
},
@{
Name = “Angela”
Age = 40
Occupation = “Human Resource”
}
)
$ObjectArray
Name Value
---- -----
Age 25
Occupation System Administrator
Name Bob
Age 40
Occupation Human Resource
Name Angela
Access
And if we want to see the the information of our second user (index 1) we do the following:
$ObjectArray[1]
Name Value
---- -----
Age 40
Occupation Human Resource
Name Angela
Update
To update a value in an array of objects we select the object we want to edit in the array and then add the property we want to change followed by the new value.
$ObjectArray[1].Age = 41
$ObjectArray[1]
Name Value
---- -----
Age 41
Occupation Human Resource
Name Angela
Array Operators
There are a number of common operators that are very useful when working with arrays. Some of these are a little different in operation than if we were using them for other data types. Let’s take a quick look at them and how to use them.
-Join
Suppose we have an array of user names and we want to display them on the screen with a comma and a space between each name. This is a typical example of something where we can put
-jointo good use.$UserNames = @("Bob","Alice","John","Jane") $UserNames -Join ", " Bob, Alice, John, JaneIf we use the
-joinwithout a delimiter than the result will be a string of the values with no spaces (or other characters) in between.-join $UserNames ## or $UserNames -Join "" BobAliceJohnJane
-Contains
With the
-containsoperator we can quickly check if the array contains a specified value. The output will be a boolean, so it can be easily be used in an If-Else statement.$UserNames = @("Bob","Alice","John","Jane") $UserNames -contains "John" True $UserNames -contains "Steve" FalseThat said, you can also check whether a value is in an array with
-in."Alice" -in $UserNames True
-eq
-eqis an example of an operator that works different on an array than, for example, on a single value. On an array it wont return a boolean, but instead all the elements that are matching.$UserNames = @("Bob","Alice","John","Jane") $UserNames -eq "Alice" Alice
-ne
-nedoes the exact opposite of-eqand will return all elements that are not matching.$UserNames = @("Bob","Alice","John","Jane") $UserNames -ne "Alice" Bob John Jane
Other Array Types
ArrayList
Unlike a traditional array, an ArrayList can grow or shrink in size as needed, making it more flexible and efficient when dealing with large datasets or unknown quantities of data. When switching from an array to an arraylist, you’ll see a mayor increase in performance. This is mostly because we don’t need to create and destroy the array while adding or removing.
It’s common to see people move to ArrayList from arrays. But it comes from a time where C# didn’t have generic support. Now that is no longer the issue, the ArrayList is deprecated and we should transition to Generic Lists. But to be complete we’ll cover this type also.
Create
# Using New-Object
$myArrayList = New-Object System.Collections.ArrayList
# Using the constructor
$myArrayList = [System.Collections.ArrayList]::new()
Add
$myArrayList.Add("Item1")
0
$myArrayList.Add("Item2")
1
The add method will return the index of the item. This might interfere with logging or other output driven script actions. To counter this you can easily pipe the output to $null.
$myArrayList.Add("Item1") | Out-Null
Remove
$myArrayList.Remove("Item1") # Removes the item with value "Item1"
$myArrayList.RemoveAt(0) # Removes the item at index 0
Access
$firstItem = $myArrayList[0] # Accesses the first item. Same as a traditional array.
Generic List
Generic lists are strongly-typed collections, meaning that we need to define the content type in front. This also reduces runtime errors.
Just as arraylists, generic lists are dynamically expandable, giving you good performance while working with them. Adding to this, the performance goes up by having a static content type.
Create
$list = [System.Collections.Generic.List[int]]::new()
Add
$list.Add(1) $list.Add(2) $list.Add(3)
Here we don’t have to deal with output of the index in contrast to arraylists.
Remove
$list.Remove(2) # Removes the element with value 2 $list.RemoveAt(0) # Removes the element at index 0
Access
$firstElement = $list[0] # Accesses the first element
Multidimensional Arrays
A multidimensional array is an array with more than one level or dimension. For example, a two-dimensional array, is an array of arrays, meaning it is a matrix of rows and columns. Think of it as a table.
Defining multidimensional arrays
Creating a multidimensional array is not that different from an array of single values. Instead of a single value on each line we write an array.
$SingleValueArray = @(
"one",
"two",
"Three"
)
$MultiDimensionArray = @(
@("One", "Two", "Three"),
@(4,5,6),
@("Seven", 8, "Nine")
)
Accessing elements
If we access the array of objects the same as we did with the single values, we get an array back instead of a single value.
$MultiDimensionArray[1]
4
5
6
But what if we want to return the value of 8? It is in the third array of the root array, so index 2. And then the second value of that array, so index 1. Or referring to the example of seeing it a a table: first we select the row, then the column.
$MultiDimensionArray[2][1]
8
Updating elements
Continuing from this, if we want to adjust a value of a multidimensional array we can do so as follows:
$MultiDimensionArray[2][1] = "Eight"
$MultiDimensionArray[2]
Seven
Eight
Nine
Leave a Reply