Working with Objects

1. The Object Pipeline

In a traditional shell the pipe | passes text, so the next command must re-parse that text every time. PowerShell's pipe passes objects — structured .NET values with named properties (like Name, CPU, Id) and methods. That single difference is the whole point of the language: you filter, sort, and select by property name instead of counting columns. Where-Object keeps or drops objects, Sort-Object orders them, and Select-Object picks the columns you care about. Read this worked example, then run it.

# PowerShell's killer feature: the pipeline passes OBJECTS, not text.
# Each process is a real .NET object with named properties (Name, CPU, Id).
# Because they're objects, you filter, sort, and pick by property — no parsing.

Get-Process |
    Where-Object CPU -gt 1 |               # keep only processes using > 1s CPU
    Sort-Object CPU -Descending |          # most CPU-hungry first
    Select-Object Name, CPU                # pick just the two columns you want

# $_ would be each object if you used a script block: { $_.CPU -gt 1 }
# Here the simple "-Property -Operator value" form needs no $_ at all.

Name              CPU
----              ---
chrome      412.84375
Code        198.39062
pwsh         54.40625
node         31.07812
explorer      6.84375

Order matters and reads left to right: filter first so later steps do less work, then sort, then select. The Where-Object CPU -gt 1 form (property, operator, value) is the easy way to filter on a single property — no $_ needed.

2. Discover Anything with Get-Member

You never have to guess what an object can do. Pipe any object into Get-Member (alias gm) and it lists every property and method, with types. Properties are the data (Name, CPU); methods are actions you call with () (ToUpper(), GetType()). This is the most important habit in PowerShell — when you're stuck, Get-Member tells you exactly what's available.

# Never guess an object's properties — ask it with Get-Member (alias: gm).
# Pipe ANY object in and it lists every Property and Method, with types.

Get-Process | Get-Member -MemberType Property |
    Select-Object Name, MemberType -First 5

# Now that you KNOW the property names, use them directly:
$p = Get-Process | Select-Object -First 1
"Name: $($p.Name)"          # $(...) runs code inside a string
"Id:   $($p.Id)"
"Type: $($p.GetType().Name)"  # call a METHOD with () — it's a .NET object

Name        MemberType
----        ----------
BasePriority  Property
Container     Property
EnableRaisingEvents Property
Handle        Property
HandleCount   Property

Name: chrome
Id:   1234
Type: Process

Notice $(...) inside the string — that's a subexpression: it runs code and drops the result into the text. Use it whenever you need a property or a method call inside "double quotes".

# 🎯 YOUR TURN — replace each ___ then run it.
# A reproducible sample set so your output matches exactly.
$files = @(
    [pscustomobject]@{ Name = 'report.docx'; SizeKB = 320 }
    [pscustomobject]@{ Name = 'photo.png';   SizeKB = 1840 }
    [pscustomobject]@{ Name = 'notes.txt';   SizeKB = 4 }
    [pscustomobject]@{ Name = 'backup.zip';  SizeKB = 9600 }
)

$files |
    Where-Object ___ -gt 300 |        # 👉 the property to filter on: SizeKB
    Sort-Object ___ -Descending |     # 👉 sort by the same property: SizeKB
    Select-Object Name, SizeKB

# ✅ Expected output:
#    Name          SizeKB
#    ----          ------
#    backup.zip      9600
#    photo.png       1840
#    report.docx      320

3. ForEach-Object and the $_ Variable

ForEach-Object (alias %) runs a script block — code in { curly braces } — once for every object in the pipeline. Inside that block, $_ (also written $PSItem) is the current object, exactly like "this item" in a loop. The same $_ appears in any Where-Object { ... } script block too. Get comfortable with it now: $_ is everywhere in PowerShell.

# 🎯 YOUR TURN — ForEach-Object runs a script block once per item.
# Inside the block, $_ is the CURRENT object flowing through the pipe.
$prices = 10, 25, 40

$prices | ForEach-Object {
    $withTax = ___ * 1.2          # 👉 multiply the current item: $_
    "Price $($_) -> with tax $withTax"
}

# ✅ Expected output:
#    Price 10 -> with tax 12
#    Price 25 -> with tax 30
#    Price 40 -> with tax 48

4. Calculated Properties

Select-Object doesn't only pick existing columns — it can build new ones. A calculated property is a small hashtable with two keys: Name (the column label) and Expression (a script block that computes the value, using $_ for the current object). This is how you turn raw bytes into megabytes, or a date into "days ago", right in the pipeline.

# Select-Object can CREATE new properties, not just pick existing ones.
# A calculated property is a hashtable: @{ Name='Label'; Expression={ ... } }.
$files = @(
    [pscustomobject]@{ Name = 'photo.png';  Bytes = 1572864 }
    [pscustomobject]@{ Name = 'backup.zip'; Bytes = 9830400 }
)

$files | Select-Object Name,
    @{ Name = 'SizeMB'; Expression = { [math]::Round($_.Bytes / 1MB, 2) } }

# $_ is the current object; 1MB is a built-in PowerShell constant (1048576).

Name        SizeMB
----        ------
photo.png      1.5
backup.zip      9.38

5. Group-Object & Measure-Object

Because the pipeline carries real data, you can do analysis without exporting to a spreadsheet. Group-Object buckets objects by a property (how many per region?). Measure-Object computes statistics in a single pass: -Sum, -Average, -Maximum, -Minimum, and a plain count. Together they answer real questions straight from the shell.

# Group-Object buckets objects by a property; Measure-Object does stats.
$sales = @(
    [pscustomobject]@{ Region = 'North'; Amount = 100 }
    [pscustomobject]@{ Region = 'South'; Amount = 250 }
    [pscustomobject]@{ Region = 'North'; Amount = 400 }
    [pscustomobject]@{ Region = 'South'; Amount = 150 }
)

# 1) Count how many sales per region:
$sales | Group-Object Region | Select-Object Name, Count

# 2) Total, average, and max across ALL sales — one pass, no loop:
$sales | Measure-Object Amount -Sum -Average -Maximum |
    Select-Object Count, Sum, Average, Maximum

Name  Count
----  -----
North     2
South     2

Count Sum Average Maximum
----- --- ------- -------
    4 900     225     400

# THE CONTRAST — same task, two worlds.

# Bash: everything is text, so you slice columns by position and hope.
#   ps aux | awk '{print $11, $3}' | sort -k2 -rn | head -3
#   Break if a column shifts, a name has a space, or the header moves.

# PowerShell: everything is an object, so you name what you want.
Get-Process |
    Sort-Object CPU -Descending |
    Select-Object -First 3 Name, CPU

# No awk, no column counting, no fragile text parsing. You asked for the
# 'CPU' property by NAME — PowerShell knows its type and sorts it numerically.

Name              CPU
----              ---
chrome      412.84375
Code        198.39062
pwsh         54.40625

# 🎯 MINI-CHALLENGE: Biggest CPU users report
# Use this sample data (don't change it):
$procs = @(
    [pscustomobject]@{ Name = 'chrome'; CPU = 45.2; Threads = 60 }
    [pscustomobject]@{ Name = 'code';   CPU = 23.1; Threads = 30 }
    [pscustomobject]@{ Name = 'idle';   CPU = 0.4;  Threads = 4 }
    [pscustomobject]@{ Name = 'node';   CPU = 12.8; Threads = 18 }
)
#
# 1. Keep only processes with CPU greater than 1   (Where-Object)
# 2. Sort them by CPU, highest first               (Sort-Object -Descending)
# 3. Show Name, CPU, and a calculated 'Status'     (Select-Object)
#    where Status is 'HOT' if CPU -gt 20, else 'ok'
#       @{ Name='Status'; Expression={ if ($_.CPU -gt 20) {'HOT'} else {'ok'} } }
#
# ✅ Expected output:
#    Name    CPU Status
#    ----    --- ------
#    chrome 45.2 HOT
#    code   23.1 HOT
#    node   12.8 ok

# your pipeline here