In PowerShell, when should you use the `ForEach-Object` cmdlet rather than the `foreach` statement, and how do the two differ in the way they consume their input?

## Two things with almost the same name `foreach` in PowerShell is overloaded, which is half the confusion: - At the **start of a statement**, `foreach` is a language keyword: `foreach ($item in $collection) { ... }`. - **After a pipe**, `foreach` resolves to an alias for the `ForEach-Object` cmdlet: `$collection | foreach { ... }`. Same word, two different execution models. Spelling out `ForEach-Object` in shared code removes the ambiguity for readers. ## How each consumes input The `foreach` **statement** evaluates its collection expression fully before the loop body runs even once. The results are collected, then iterated: ```powershell foreach ($line in Get-Content .\big.log) { if ($line -match 'ERROR') { $line } } ``` `Get-Content` runs to completion and every line is held before the first `if` executes. On a 5 GB log that is a memory problem, not a style problem. `ForEach-Object` is a cmdlet occupying a pipeline stage. Objects arrive one at a time, the script block runs with `$_` (equivalently `$PSItem`) bound to the current item, and anything the block emits flows immediately to the next stage: ```powershell Get-Content .\big.log | ForEach-Object { if ($_ -match 'ERROR') { $_ } } ``` Here `Get-Content` streams, the script block runs per line, and memory stays flat regardless of file size. The same shape is what lets `ForEach-Object` sit in the middle of a longer pipeline. `ForEach-Object` also accepts `-Begin` and `-End` script blocks that run once before and after the stream, which is how you set up and tear down state around a streaming operation — the statement form has no equivalent because you simply write code before and after the loop. There is a shorthand worth knowing: `ForEach-Object PropertyName` (the `-MemberName` parameter, positional) projects a member without a script block, and `ForEach-Object MethodName` calls a method on each item. ## Speed versus memory On a collection that already fits in memory, the `foreach` statement is faster — often several times faster — because the cmdlet pays pipeline and script-block-invocation overhead per object. On a stream you cannot or should not materialise, `ForEach-Object` wins outright because the statement's collect-first behaviour is exactly what you are trying to avoid. That is the whole tradeoff: **statement = speed on materialised data; cmdlet = streaming and composability**. A middle path many people forget: you can pipe into `ForEach-Object` for the streaming half and use a plain `foreach` statement inside it for a small nested collection. ## Control flow is not the same This is the trap that separates a rehearsed answer from a real one. In the `foreach` statement, `break` exits the loop and `continue` skips to the next item — the ordinary meaning. Inside a `ForEach-Object` script block there is no loop, only a script block invoked repeatedly. Consequently: - `return` ends processing of the **current item** and moves to the next. It does not return from the enclosing function. - `break` and `continue` are not scoped to the cmdlet. They look for an enclosing loop; with none present, `break` terminates the pipeline rather than skipping one item. People write `continue` expecting "skip this object" and get behaviour they did not intend. So: to skip an item inside `ForEach-Object`, use `return` (or restructure with a `Where-Object` filter upstream, which is usually clearer and faster). ## Parallelism (PowerShell 7) `ForEach-Object -Parallel { ... }` runs the script block for multiple items concurrently in separate runspaces, with `-ThrottleLimit` capping concurrency. Because each runspace is isolated, variables from the caller must be referenced as `$using:varName`, and ordering of output is not guaranteed. It is a genuine win for I/O-bound work — hitting many hosts or URLs — and usually a loss for cheap CPU-light work, where runspace setup costs more than the work itself. There is no parallel form of the `foreach` statement. ## Choosing, in practice - Data already in a variable, and you want speed → `foreach` statement. - The input is a stream, a huge file, or you are mid-pipeline → `ForEach-Object`. - You need `break` to abandon the loop early on a materialised collection → statement (clean semantics). - You need per-item work fanned out concurrently → `ForEach-Object -Parallel` on PowerShell 7. - You just want a property or a method call on each item → `ForEach-Object Name` shorthand, or `Select-Object -ExpandProperty`.