close

Windows

Cloud

Microsoft 365

PowerShell

Active Directory

Security

Windows Server

Video

Microsoft Teams Day is back!

Home

PowerShell

How to Use a PowerShell Array

Michael Reinders

|
PowerShell

A PowerShell array is a data structure designed to store an item or a collection of items. These item types can be the same or of varying types.

In this article, we’ll explain how PowerShell arrays work, how to use an array of objects, and everything you need to know about PowerShell arrays to become a power user.

What is a PowerShell array?

As you may already know, arrays are used by most programming languages. Starting with PowerShell 3.0, a collection of zero or an object has at least some properties of arrays.

A PowerShell array is your answer whenever you need to gather or even manipulate multiple pieces of data, especially when you’re using PowerShell scripting. That’s because when working with an array, you can use a single command to perform the same service on a collection of items or individually manipulate them. It provides a beautiful and adaptable tool in this regard.

Data types in a PowerShell array

There are several different data types you can have in an array including Object and Int32. Each of the items in an array can contain any number of these data types. This is precisely what makes them so versatile.

Each of the data items has an index. Somewhat strangely, the index starts at 0. The first item in an array will be given an index of zero, and the next, 1. And so on…

We’ll learn more about the different types of arrays and their syntax throughout the remainder of this guide.

PowerShell array example

By illustrating what a PowerShell array is with an example, I’ll be able to show you how this works easily.

First, let’s create an object array with the following command:

$ArrayOne = @("Title", "Files", "c:\Install")

We can determine the type of the array with the GetType() command.

$ArrayOne.GetType()

Then, let’s try an [int32] or integer array.

[int32[]]$ArrayListing1 = 10,20,30,40,50
$ArrayListing1.GetType()
Learning about PowerShell array data types
Learning about array data types

From the first example, we see it’s an ‘Object’ array. The second is an ‘integer’ array. 

How to create and edit a PowerShell array

Alright, let’s create some content, shall we? Again, a PowerShell array can take any type of data. An array type defines the structure of data. We will also pursue creating arrays that can take only specific types of data, per our wishes.

Let’s start with creating an array that will contain any data type. We’ll create an array variable – ‘$ArrayOne’.

Per our previous example:

$ArrayOne = @("Document", "FileSystem", "D:\PS-Tutorial")

Because we didn’t specify a data type, the array can take any. However, I’ll now show you how to create an array while specifying a specific data type. We will prepend the variable name with the data type. Watch this:

[int32[]]$NumberedList = @('50', '75', '100')
Stating a data type when creating an array
Stating a data type when creating an array

I’ll sneak another topic here – the strongly typed array. We can set an array to ONLY contain a specific data type. As an example, this command will force the array to only allow integers:

[int[]] $integers = 55,66,77

How to add or remove data to an array

Next, I’ll describe how we can add, remove, and append data on an existing array. Actually, up to this point, we’ve created arrays adding data right from the start. The default size of arrays, incidentally, is defined by the initial creation of the array.

Let’s first create an empty array:

$FileNames = @()
Creating an empty array
Creating an empty array

I know, not much there. So, before we add an entry to this array, we need to convert it into a list so it can accept additional indexed entries of data. We accomplish this with the [System.Collections.ArrayList] command:

[System.Collections.ArrayList]$FileNamesList = $FileNames
$FileNamesList.Add("Patterns")
$FileNamesList
Being able to add data points to a PowerShell array
Being able to add data points to an array

We’ve created a new ‘list’ array – FileNamesList – based on our existing and empty ‘$FileNames’ array. Then, we added the first indexed entry (at 0) – ‘Patterns’ – Not too bad, huh? I’ll add a few more items to our array, then show you how to remove an item or two.

And, by the way, you can get easy access to your array elements by typing the variable name by itself – ‘$FileNamesList’ above.

Adding more entries to an array
Adding more entries to an array

Let’s remove the last data piece – ‘Complete’. We use the corresponding Remove command.

$FileNamesList.Remove("Complete")
Removing an item from an array
Removing an item from an array

Piece of cake.

Updating existing items in an array

It’s pretty easy to make a change to an item in your array. As long as you know the index record of the data point you wish to change, you can make the change right away.

First, let’s list the contents of our ‘$FileNamesList’ array:

$FileNamesList

Here, I would like to update the 2nd entry (Index ‘1’) from ‘Embroidery’ to ‘Secondhand’. Here’s how to do it:

$FileNamesList[1] = 'Secondhand'
Updating an existing data point in an array
Updating an existing data point in an array

I do like how simple the manipulations of arrays can be, don’t you?

Iterated actions

One of the most powerful aspects of PowerShell is being able to perform repetitive actions or tasks on many objects at once. In a similar fashion, we can add a description to the beginning of our data points by using the ForEach-Object command.

Let’s try adding ‘Preferred’ at the beginning of our data points:

$FileNamesList | ForEach-Object {"Preferred: [$PSItem]"}
Using iterated actions on an array
Using iterated actions on an array

Very cool.

How to use PowerShell operators in an array

Pretty much all of the operators that we use for single data items in PowerShell also work with arrays. However, there are some differences. Let’s take a look at the most common operators and how you can use them in your arrays.

Join

The join operator is arguably the most often used command in PowerShell, and it’s extremely useful when working with arrays. You can use it iteratively (efficient!) on the items in an array to join items together for the output purpose.

Let me show you how it works. First, we’ll create an array:

$List = @(100,150,200,250,300)

Then, we’ll use the ‘-join’ command to add a ‘-‘ in between each item when showing the output.

$List -join '-'
Using the -join operator in an array
Using the -join operator to add a ‘-‘ in between each item

Very nice. It’s relatively easy to discover how these operators could make it simple to manipulate on-screen data and even logged output!

Contains

We can use the contains operator to find out if an array has an existing data point or not. The Boolean True or False terms signify to us the answer.

$List -contains '150'
$List -contains '175'
Here, we use the -contains operator to identify data in an array
Here, we use the -contains operator to identify data

My goodness, even a Ferengi could figure THIS out…

Equals / Not equals

Lastly, I’ll explain a subtle difference in how to use the equals and not equals comparison operators. These are the same as -eq and -ne.

When you use the -eq switch, PowerShell will output the value if it is True, not False. The –ne switch (not equal) will output every value in your array that does NOT match your request. Yes, it’s a little different.

Let me show you how it works with an example:

$List -eq '200'
$List -ne '100'
Using equals and not equals to identify data in our array
Using equals and not equals to identify data in our array

On the first line, it simply outputs the entry matching the request, ‘200’. On the second line, it listed all the array members that were not equal to ‘100’. Using the correct format (syntax) of these commands is crucial!

Multi-dimensional arrays

You can also create a multi-dimensional array by altering the syntax of the array. This allows you to easily create a multi-data type array from the start.

Let me show you an example:

$MultiList = @( ("files","folders","containers"),(300,500,700))
$MultiList[1][1]
Multi-dimensional arrays!

The second command requests the output of the data entry at the row and column of [1,1]. Think about this as an Excel table where we’re looking at the cell in the second column over and the second row down.

How to access array objects

You’ve seen an example or two sprinkled into my post thus far on how to retrieve the information in an array. Let me show you the basic syntax on how to do this for your arrays.

If we look at our $List array, we see 5 indexed entries. If we want to retrieve the third entry, we use the index of ‘2’.

$List
$List[2]
We have 5 indexed entries in our $List array

How to loop through an array

There are two fundamental examples of using the ForEach statement with PowerShell arrays – the method and the loop. We use this to process every item in an array to gather the information we’re looking for, or to manipulate all the entries in our array at once. 

Using the ForEach method

To use the ForEach Method to loop through an arrayhere’s how we will proceed:

  • We first enter a period next to the variable for the array.
  • Next, we enter ‘ForEach’ followed by square brackets.
  • Within the ‘()’ brackets, we include the other brackets, ‘{}’.
  • We enter the command to run against all the items and include the automatic pipeline variable ‘$_’.

Let me show you an example. We can get the 10 newest entries from the Event Viewer from each of the 3 ‘core’ log types – System, Application, and Security. We just separate each entry with a comma.

$LogNames = @("System", "Application", "Security")
$LogNames.ForEach({ Get-EventLog -LogName $_ -Newest 10 })
Getting the 10 most recent log entries from Event Viewer
Getting the 10 most recent log entries from Event Viewer

We first store the 3 types of logs in our variable. Then, we use the ForEach method to grab the 10 newest log entries from each type and output them. Very powerful, and very efficient.

Using a ForEach loop

Now let’s use a similar loop structure (script block) to perform the same request. The main difference here is instead of using ‘$_’ as a temporal variable, we store each run-through in a temporary variable (LogNames).

Let me show you how it works with an example:

ForEach ($LogName in $LogNames) { Get-EventLog -LogName $LogName -Newest 10 }
Here we use a ForEach loop method to get the same information
Here we use a ForEach loop method to get the same information

Voila. And, let me point out a massive performance boost in using PowerShell vs. the GUI. Running this command, which outputs the 10 most recent log entries from the System log, the Application log, and the Security log takes a blink of an eye. Opening the Event Viewer MMC tool, navigating to each of these logs, and saving the most recent 10 entries takes a minute even on a fast computer. What amazing time savings!

How to create an array of objects

So far, we’ve shown you how to create an array with basic data. Most notably a string or an integer. However, arrays can also contain objects. Many of the most common uses of PowerShell, especially when working in Office 365 dictate that you use objects instead.

We can use similar functions to create an array of objects. It’s all about the syntax. We’ll create a (very) basic directory of users. Let’s use this example.

$users = @( [pscustomobject]@{FirstName='Billy';LastName='Reinders'},[pscustomobject]@{FirstName='Michael'; LastName='Reinders'} )
$users

We’ve entered the two names into the array and shown the output. Nice and easy. We can also access the individual properties of each object by specifying them as we’ve done already.

$Users[1].FirstName

As this is index #1, we know this is the second entry. So, we should get back ‘Michael’. Let’s see.

Finding specific entries in our table
Finding specific entries in our table

Yes, that worked as expected!

How to iterate through an array of objects

Using similar syntax, we can iterate through our entries and make a change. Let’s say Billy got married and is taking his spouse’s last name (Jones). We can update our array with one step!

$Users[0].LastName = 'Jones'
Updated an entry after an employee's last name changed
Updated an entry after an employee’s last name changed

You have to hand it to Microsoft, they really built a nice scripting language.

I’d like to show a more pointed example of going through our entire array for a purpose. We can access the same property of all of our objects and get that output using the ForEach-Object cmdlet.

$Users | ForEach-Object {$_.LastName}
Using the ForEach 'method' to get all the last names
Using the ForEach ‘method’ to get all the last names

Pre-sized arrays, multiplying arrays, and nested arrays

Lastly, I’ll show you some more advanced array functions in your arsenal that can definitively boost your efficiency when scripting with arrays.

Pre-sized arrays

Taking a step back briefly, creating an array up to this point we’ve determined the size of the array by the number of items in it. However, we can create a pre-sized-array, which is an array with a specified size.

To create a pre-sized array, we’ll use the new($size) constructor. Here’s an example.

$Table = [Object[]]::new(8)
$Table.Count
Creating an array with a pre-defined size
Creating an array with a pre-defined size

Even though there are no entries yet in our new array, the ‘Count’ does list 8 (empty) entries.

Multiplying arrays

Multiplying arrays can be rather confusing for some users, but it really comes down to repeating values the specified number of times. Let me show you.

$Table = @('Michael','Billy','Fred')
$Table * 3
Multiplying our array by '3'
Multiplying our array by ‘3’

Here, we simply took the original 3 entries and multiplied them 3 times. Now we have 3 *3 = 9 entries.

Nested arrays

Similar to other programming languages, we can use nested arrays to create a classic matrix, so to speak. Let me demonstrate with a two-dimensional array.

$Array1 = @(@100,200,300),@(400,500,600),@(700,800,900))
$Array1[0,2]
$Array1[0][2]
Using nested arrays to span dimensions
Using nested arrays to span dimensions…

So, first, we add the 9 entries to the array, 100 – 900. Then, when we specify the second command, we are asking for the entries in the first row and the third row. And, with the last command, we are asking for the single entry at row 0, column 2 – ‘300’. Piece of cake!

Conclusion

Well, I hope you learned as much as I did! Yes, seriously, I am on a learning module of sorts with PowerShell as I go through this series of posts. Catching up on some of the ‘basics’ of PowerShell is ALWAYS fruitful for me. I often times use something I learned or re-learned just days before in my professional IT life.

If you have any questions or comments, please feel free to leave a comment below. Thank you for reading!

Most popular on petri

Article saved!

Access saved content from your profile page. View Saved