PowerShell append objects to variable list

Question

Fairly new to PowerShell and wanting to learn how to append objects to a variable list. Below is the error message:

Method invocation failed because [System.IO.FileInfo] does not contain a method named 'op_Addition'.
At C:\Users\Username\Desktop\Sandbox\New folder\BoxProjectFiles.ps1:117 char:4
+             $MechDWGFile += $file
+             ~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (op_Addition:String) [], RuntimeException
    + FullyQualifiedErrorId : MethodNotFound

and code:

LogWrite "`n-------------Mechanical Drawing(s)------------"
foreach ($file in $MechDWGList)
{
    # Where the file name contains one of these filters
    foreach($filter in $MechDWGFilterList)
    {
        if($file.Name -like $filter)
        {
            $MechDWGFile += $file # this is where the error is happening, so I know it is probably something simple
            LogWrite $file.FullName
        }
    }
}

PowerShell 5.1 and Windows 10 OS is being used.

Could someone help me understand what's wrong with my syntax?

Mathias R. Jessen · Accepted Answer · 2022-01-29 01:54:56Z

7

Based on the error message, $MechDWGFile already contains a single [FileInfo] object - the type of object returned by Get-Item or Get-ChildItem.

The += operator is overloaded in PowerShell, meaning its behavior depends on the type of object you have on the left-hand side - in this case $MechDWGFile which contains a [FileInfo] object.

$file also contains such an object, but [FileInfo] + [FileInfo] doesn't make any sense, which is why you see the error.

To make the += operator work, you need to create an array with the @() array subexpression operator:

$MechDWGFile = @()

# ...

# This now works
$MechDWGFile += $file

If you've initialized $MechDWGFile with output from Get-Item or Get-ChildItem, simply nest the existing pipeline in @():

# `Get-ChildItem |Select -First 1` will only output 1 object, 
# but the @(...) makes PowerShell treat it as a 1-item array
# which in turn allows you to use `+=` later
$MechDWGFile = @(Get-ChildItem -Recurse -File |Select -First 1)

answered Jan 29, 2022 at 1:54

Mathias R. Jessen

178k13 gold badges175 silver badges234 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Screamcheese Over a year ago

MathiasR.Jessen, understood. Thank you this makes sense! I tried initializing $MechDWGFile but without the = @(), just as = $null and = 0. Trying to grasp the @ in PowerShell still, thought it was mostly meant for hash tables.

Damian T. · Accepted Answer · 2022-01-31 23:34:34Z

2

One big caveat about arrays in PowerShell—they are immutable.

Although you can "add" elements to an array in PowerShell using the overloaded += operator, what it essentially does is creates a new array with the elements of the first operand and the second operand combined.

This may be more of a personal preference, but when I plan on looping over a bunch of items to populate an array, I use an [ArrayList] instead. ArrayLists are mutable by design. Why this isn't the default in PowerShell, I have no idea.

Adding a new element to an existing array:

$Array1 = Get-ChildItem -Path 'C:\'
$Array2 = @()

# Add only the directories to our second array
foreach ($Item in $Array1) {
    if ($Item.PSIsContainer) {
        $Array2 += $Item    # This creates a new array every time
    }
}

$Array2

Adding a new element to an existing [ArrayList]:

$Array1 = Get-ChildItem -Path 'C:\'
$Array2 = [System.Collections.ArrayList]@()

# Add only the directories to our ArrayList
foreach ($Item in $Array1) {
    if ($Item.PSIsContainer) {
        $null = $Array2.Add($Item)    # This does not create a new object each time.

        # The $null= prepend is because [ArrayList].Add() will output the ID of the
        #   last element added, so we assign that to null, keeping our console clean.
    }
}

$Array2

Side note: Like Mathias has stated, your variable $MechDWGFile may not have been initialized as an array, which is why the += overload operator didn't work and instead threw an error.

answered Jan 31, 2022 at 23:34

Damian T.

3322 silver badges10 bronze badges

2 Comments

Screamcheese Over a year ago

DamianT. thank you for clarifying. It's a little confusing and eventually I'd like to learn more on the differences between arrays and arraylists, other than their immutability/mutability. One question, by using the overloaded += operator which essentially creates a new array, does this mean that the active buffer has more consumed until the script ends/terminates? i.e. does the old array still exist when using the `+=' operator which now creates an additional array "in the buffer"?

Damian T. Over a year ago

The main difference is that when adding to an array, you are creating a new array object and then assigning the reference to your variable handle $MechDWGFile. Each time you do that, the original object that was created is still in memory, but that memory is marked as free. This means that you are making the system allocate and deallocate memory over and over. It's inefficient. When iterating many times over large amounts of data, adding to ArrayLists are more efficient because you're expanding the ArrayList itself instead of creating multiple arrays like (a), (a,b), (a,b,c), etc.

Collectives™ on Stack Overflow

PowerShell append objects to variable list

2 Answers 2

1 Comment

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related