Powershell ExpandProperty changes source object – why?

Welcome to this article, where we’ll dive into the mysterious world of PowerShell and explore one of its most intriguing behaviors: how the Select-Object cmdlet’s ExpandProperty parameter changes the source object. Yes, you read that right – changes the source object!

What is ExpandProperty, anyway?

Before we dive into the why, let’s quickly cover the what. The ExpandProperty parameter is a part of the Select-Object cmdlet, which is used to select specific properties from objects in PowerShell. When you use ExpandProperty, you’re telling PowerShell to retrieve the value of a specific property and return it as a new object.

Get-Process | Select-Object -ExpandProperty Name

In this example, we’re using Get-Process to retrieve a list of processes, and then selecting only the Name property using Select-Object. The -ExpandProperty parameter tells PowerShell to return the value of the Name property as a new object.

The mystery of the changing source object

Now, here’s where things get interesting. When you use ExpandProperty, you might expect that the original object remains unchanged. After all, you’re only selecting a specific property, right? Well, not exactly.

It turns out that when you use ExpandProperty, PowerShell actually modifies the original object. Yes, you read that right – modifies the original object!

$processes = Get-Process
$processes | Select-Object -ExpandProperty Name
$processes

In this example, we first retrieve a list of processes using Get-Process and store it in the $processes variable. Then, we use Select-Object with -ExpandProperty to select only the Name property. Finally, we print the contents of the $processes variable again.

What do you think happens? Do you think the $processes variable still contains the original list of processes? Think again!

$processes
 Handles  NPM(K)    PM(K)      WS(K)     CPU(s)      Id  SI ProcessName
-------  ------    -----      -----     ------      --  -- -----------
    134       25    10476      20540       3.06    2360   1 calc
    544       26    12316      24340       3.03    2640   1 chrome
    ...

$processes
calc
chrome
...

As you can see, the original list of processes is now replaced with a list of process names! This is because ExpandProperty modified the original object, replacing it with a new object containing only the selected property.

Why does this happen?

So, why does PowerShell behave in this way? The answer lies in the way PowerShell handles objects and piping.

In PowerShell, when you pipe objects to a cmdlet, the objects are not passed by value, but rather by reference. This means that the cmdlet receives a reference to the original object, rather than a copy of the object.

When you use ExpandProperty, PowerShell modifies the original object by replacing it with a new object containing only the selected property. This is because the Select-Object cmdlet is designed to work on the pipeline, modifying the objects as they pass through.

How to avoid the side effects

So, how can you avoid this unexpected behavior? There are a few ways to do so:

• Use the -NoExpand parameter

  You can use the -NoExpand parameter with Select-Object to prevent the original object from being modified.

  $processes | Select-Object -ExpandProperty Name -NoExpand

• Use a new variable

  Instead of modifying the original object, you can store the result of the Select-Object cmdlet in a new variable.

  $processNames = $processes | Select-Object -ExpandProperty Name

• Use the Foreach-Object cmdlet

  You can use the Foreach-Object cmdlet to iterate over the objects and extract the desired property without modifying the original object.

  $processes | Foreach-Object {$_.Name}

Conclusion

In conclusion, the ExpandProperty parameter of the Select-Object cmdlet can have unexpected side effects, modifying the original object in the process. By understanding how PowerShell handles objects and piping, you can avoid these side effects and use ExpandProperty with confidence.

Remember, when working with PowerShell, it’s essential to understand the underlying mechanics of the language to avoid unexpected behavior and ensure your scripts run smoothly.

Thanks for joining me on this journey into the world of PowerShell! If you have any questions or feedback, feel free to leave a comment below.

Stay PowerShell-ful, my friends!

Frequently Asked Question

Get ready to unleash the power of PowerShell and unravel the mystery of ExpandProperty!