{"id":1042,"date":"2014-07-08T00:01:00","date_gmt":"2014-07-08T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2014\/07\/08\/getting-to-know-foreach-and-foreach-object\/"},"modified":"2014-07-08T00:01:00","modified_gmt":"2014-07-08T00:01:00","slug":"getting-to-know-foreach-and-foreach-object","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/getting-to-know-foreach-and-foreach-object\/","title":{"rendered":"Getting to Know ForEach and ForEach-Object"},"content":{"rendered":"

Summary<\/b>: Learn the differences between ForEach<\/strong> and ForEach-Object<\/strong> in Windows PowerShell.<\/span><\/p>\n

Honorary Scripting Guy and Windows PowerShell MVP, Boe Prox<\/a>, here today filling in for my good friend, The Scripting Guy. Today I am going to talk about some differences between using ForEach<\/b> and using ForEach-Object<\/b> in day-to-day scripting activities.<\/p>\n

There are times when you are unable to make use of a cmdlet that has built-in pipeline support, such as something like this:<\/p>\n

Get-ChildItem –File –Filter “*.TMP” | Remove-Item –Verbose<\/p>\n

To get around this, we can make use of some other capabilities of Windows PowerShell by using ForEach<\/b> or ForEach-Object<\/b> to iterate through collections and to perform an action against each item in the collection. Each of these approaches can let you run through a collection and then perform actions in a script block. What you may not know is that each cmdlet has two approaches to how they take and handle the collections.<\/p>\n

Let's take a look at ForEach-Object<\/b> and see what it is about. This cmdlet has a couple of aliases that may seem familiar to you:<\/p>\n

Get-Alias –Definition ForEach-Object<\/p>\n

\"Image<\/a><\/p>\n

Wait a second! Why in the world are there two ForEach<\/b> options in Windows PowerShell? This is an excellent question, and fortunately, I have an answer. When you are piping input into ForEach<\/b>, it is the alias for ForEach-Object<\/b>. But when you place ForEach<\/b> at the beginning of the line, it is a Windows PowerShell statement.<\/p>\n

ForEach-Object<\/b> is best used when sending data through the pipeline because it will continue streaming the objects to the next command in the pipeline, for example:<\/p>\n

ForEach-Object -InputObject (1..1E4) {<\/p>\n

    $_<\/p>\n

} | Measure-Object<\/p>\n

 <\/p>\n

Count    : 10000<\/p>\n

Average  :<\/p>\n

Sum      :<\/p>\n

Maximum  :<\/p>\n

Minimum  :<\/p>\n

Property :<\/p>\n

You cannot do the same thing with ForEach () {}<\/b> because it will break the pipeline and throw error messages if you attempt to send that output to another command.<\/p>\n

ForEach ($i in (1..1E4)) {<\/p>\n

    $i<\/p>\n

} | Measure-Object<\/p>\n

 <\/p>\n

At line:3 char:3<\/p>\n

+ } | Measure-Object<\/p>\n

+   ~<\/p>\n

Note that an empty pipe element is not allowed.<\/p>\n

    + CategoryInfo          : ParserError: (:) [], ParentContainsErrorRecordException<\/p>\n

    + FullyQualifiedErrorId : EmptyPipeElement<\/p>\n

You would have to save all of the output that is being process by ForEach<\/b> to a variable and then pipe it to another cmdlet, for example:<\/p>\n

$Data = ForEach ($i in (1..1E4)) {<\/p>\n

    $i<\/p>\n

}<\/p>\n

$Data | Measure-Object<\/p>\n

The fact that now we have totally broken the pipeline becomes more apparent after this. Not only do we have to stop the pipeline to begin processing the data, we cannot even send that data to the pipeline from the statement without first collecting the output into a variable and then sending it down the pipeline.<\/p>\n

This is very important if you plan to use the data in another command through the pipeline. It is important to note another difference that these options share, which is performance vs. memory consumption.<\/p>\n

The ForEach<\/b> statement loads all of the items up front into a collection before processing them one at a time. ForEach-Object<\/b> expects the items to be streamed via the pipeline, thus lowering the memory requirements, but at the same time, taking a performance hit. Following are a couple of tests to highlight the differences between these:<\/p>\n

$time = (Measure-Command {<\/p>\n

    1..1E4 | ForEach-Object {<\/p>\n

        $_<\/p>\n

    }<\/p>\n

}).TotalMilliseconds<\/p>\n

 [pscustomobject]@{<\/p>\n

    Type = 'ForEach-Object'<\/p>\n

    Time_ms = $Time<\/p>\n

 }<\/p>\n

 <\/p>\n

$Time = (Measure-Command {<\/p>\n

    ForEach ($i in (1..1E4)) {<\/p>\n

        $i<\/p>\n

    }<\/p>\n

}).TotalMilliseconds<\/p>\n

  [pscustomobject]@{<\/p>\n

    Type = 'ForEach_Statement'<\/p>\n

    Time_ms = $Time<\/p>\n

 }<\/p>\n

\"Image<\/a><\/p>\n

As expected, the ForEach<\/b> statement, which allocates everything to memory before processing, is the faster of the two methods. ForEach-Object<\/b> is much slower. Of course, the larger the amount of data, the more risk you have of running out of memory before you are able to process all of the items. So be sure to take that into consideration.<\/p>\n

To throw another curve ball into this, check out this alternate approach to ForEach-Object<\/b>. This time, we'll use the InputObject<\/b> parameter (this is the parameter used in the pipeline process):<\/p>\n

$Time = (Measure-Command {<\/p>\n

    ForEach-Object -InputObject (1..1E4) {<\/p>\n

        $_<\/p>\n

    }<\/p>\n

}).TotalMilliseconds<\/p>\n

 [pscustomobject]@{<\/p>\n

    Type = 'ForEach-Object_Param'<\/p>\n

    Time_ms = $Time<\/p>\n

 }<\/p>\n

\"Image<\/a><\/p>\n

Wow, that was fast! Why am I not talking this up instead of focusing on ForEach<\/b>? Although this seems like the fastest of the three approaches, the major (yes, major!) issue is that we are being deceived into thinking that it just processed everything in an amazing amount of time. But the fact is that all we did was pass the entire collection to the script block one time—and that was it.<\/p>\n

ForEach-Object -InputObject (1..1E4) {<\/p>\n

    $_.GetType().FullName<\/p>\n

}<\/p>\n

\"Image<\/a><\/p>\n

Well, it was worth a shot to squeeze a little more speed out of this. But in the end, we get something that is completely unusable—even if we did want to send it down the pipeline. <\/span><\/p>\n

ForEach-Object<\/b> also allows us to specify Begin<\/b>, Process<\/b>, and End<\/b> script blocks that we can use (similar to an advanced function) to set up our environment, process each item, and then do something (such as clean up at the end of the command).<\/p>\n

Get-ChildItem -Force | ForEach-Object -Begin {<\/p>\n

    Write-Verbose "Begin block" -Verbose<\/p>\n

} -Process {<\/p>\n

    If ($_.length -gt 555) {<\/p>\n

        Write-Verbose "Process block" -Verbose<\/p>\n

        $_<\/p>\n

    }<\/p>\n

} -End {<\/p>\n

    Write-Verbose "End block" -Verbose<\/p>\n

}<\/p>\n

\"Image<\/a><\/p>\n

Here you see that the Begin<\/b> block kicks off first, followed by all of the items that I am processing and filtering, with the End<\/b> block being processed last. If I wanted, I could then pass this to another cmdlet, such as Export-CSV<\/b>. You couldn’t come close to doing this type of action by using the ForEach<\/b> statement.<\/p>\n

So which one do you use? Well, the answer is, “It depends.”<\/p>\n

You can iterate through a collection of items by using either the ForEach<\/b> statement or the ForEach-Object<\/b> cmdlet.<\/p>\n