I had some comments on a recent performance comparison article that were well received and encouraged me to write some more of these similar articles. So without further ado, lets get started on looking at adding items to an array and which approach would be better in terms of performance.

Typically, the most common approach that I see with adding items to an array in PowerShell is through the use of the += operator.

 
$a = @()
$a += 'data'
$a
$a += 'test'
$a

I had to first initialize the array, otherwise my attempts to add the text would instead be treated as concatenating text, which is not what I am looking for in this example. As I said, this is the common approach that I see, but is it necessarily the fastest approach? Well, the answer is no.

Using an ArrayList

The answer to better performance is in the use of an ArrayList. As you may see more and more with getting better performance out of PowerShell, you will typically see a move towards using some .Net instances to perform similar operations that can be done using actual PowerShell commands or operators. So something that I did above can be done like the following:

 
$a = New-Object System.Collections.ArrayList
$a.Add('data')
$a.Add('test')
$a

The 0 and 1 that you see being outputted each time I add an item indicates the index of which the item was added into the collection. So ‘data’ was added at the 0 index and ‘test’ was added to the 1 index. This can be pretty annoying in my opinion and can pollute the pipeline and bring undesirable results. You can get around this by making sure that data is sent to a Null location.

We have two options for creating a collection of items set up before us, but the next question is which one is the quickest? Let’s find out!

 
@(1E1,1E2,1E3,1E4,1E5) | ForEach {
    $Time = (Measure-Command {
        $array = @()
        1..$_ | ForEach {
            $array+=$_
        }
    }).TotalMilliseconds
     [pscustomobject]@{
        Type = '+='
        Time_ms = $Time
        Count = $_
    }

    $Time = (Measure-Command {
        $list = New-Object System.Collections.ArrayList
        1..$_ | ForEach {
            [void]$list.Add($_)
        }
    }).TotalMilliseconds
     [pscustomobject]@{
        Type = 'ArrayList'
        Time_ms = $Time
        Count = $_
    }
} | Sort Count | Format-Table -AutoSize

I’m not saying that ArrayList won every time…wait, I am saying that! As the total number of items added to each collection increased, the time also increased for each of the approaches with the += increasing rather dramatically near the end. What is happening with the += operator is that it actually builds out a new array each time you use the operator so it can add the new item to the collection. Not exactly efficient, but it gets the job done. You won’t find that with the ArrayList approach as it adds the item right into the collection.

As with any of these types of performance tests, I covered the simple up the extreme type of situations, so if you absolutely want to squeeze every possible millisecond out of your PowerShell scripts, then you would definitely want to look at the ArrayList approach.