The Pipeline: Passing Objects, Not Text

Chapters 1 through 3 have already used Where-Object, Sort-Object, and Select-Object in passing — enough to show that filtering happens by real property, not text pattern. This chapter goes underneath that and treats the pipeline as the subject in its own right: how it actually moves objects from one cmdlet to the next, the two different ways to write a Where-Object filter, the comparison operators available once you're inside one, and the real difference between Select-Object's two shaping modes — a distinction that causes genuine confusion the first time it bites.

One Object at a Time, Not One Big Blob

A PowerShell pipeline doesn't run the first cmdlet to completion, hand off one giant collection, then run the second cmdlet on all of it. Each object produced by one stage is pushed into the next stage individually, as soon as it's available — Get-Process can start handing processes to Where-Object before it has even finished enumerating every running process on the system. This is part of why PowerShell pipelines stay responsive on large result sets: you often see output start scrolling before the upstream cmdlet has fully finished.

$_ (a.k.a. $PSItem): "Whatever Object Is Passing Through Right Now"

Inside a script block running per pipeline object, $_ refers to that one current object — the object being evaluated this time through, not the whole collection. $PSItem is an identical, more readable alias for the exact same thing; both are used interchangeably in real scripts.

Two Ways to Write a Where-Object Filter

For a single, simple comparison, PowerShell offers a shorter simplified syntax that skips $_ entirely — property name, operator, value:

The simplified form reads cleanly for the common case, but it only supports a single property comparison — the moment you need to combine two conditions with -and/-or, or reference a computed expression rather than a bare property, the script-block form with $_ is what you actually need.

Comparison & Logical Operators

Every one of these is spelled with a leading dash, not a symbol — PowerShell doesn't use ==, >, or && for these comparisons the way Bash's [[ ]] or JavaScript would, precisely because > and < are already taken for file redirection, the same way they are in Bash itself.

Select-Object: Shaping What Comes Out

Select-Object does two genuinely different jobs depending on which switch you reach for, and mixing them up is a real, common gotcha:

-Property gives you back a trimmed-down object — still an object, with ProcessName and CPU attached, just fewer properties than before. -ExpandProperty gives you back the raw value itself, with the object wrapper stripped away entirely. That distinction matters the moment you pipe the result somewhere else, or compare it directly: a -Property result compared with -eq "chrome" will never match, because you're comparing a whole object against a string — you needed -ExpandProperty for that.

Select-Object also takes -First/-Last (already used above and in Chapter 1), -Skip (skip a number of leading results), and -Unique (drop duplicate rows, compared by whichever properties were selected).

ForEach-Object: Doing Something With Each Object

Where Where-Object decides whether an object continues down the pipeline, ForEach-Object runs an action against every object that reaches it — the pipeline's own equivalent of a loop body, using the same $_:

foreach as a standalone loop keyword (rather than the ForEach-Object cmdlet shown here) is genuinely different and gets its own proper treatment in Chapter 6 — for now, just note that this chapter's ForEach-Object is a pipeline stage, not the loop syntax you'll write inside a script body.

Putting It Together: A Real Multi-Stage Pipeline

Hands-On Exercises