Pipeline input (ValueFromPipeline) in PowerShell - Step-by-Step Execution

Concept Flow - Pipeline input (ValueFromPipeline)

Start script

↓

Define function with ValueFromPipeline

↓

Send objects into pipeline

↓

PowerShell passes each object

↓

Function receives object via pipeline

↓

Process object inside function

↓

Output processed result

↓

End

The script defines a function that accepts input from the pipeline, processes each input object one by one, and outputs results.

Execution Sample

PowerShell

function Show-Name {
  param(
    [Parameter(ValueFromPipeline=$true)]
    [string]$Name
  )
  process {
    Write-Output "Hello, $Name!"
  }
}

"Alice","Bob" | Show-Name

This script defines a function that takes names from the pipeline and greets each name.

Execution Table

Step	Pipeline Input	Parameter Value	Action	Output
1	"Alice"	Alice	Function receives 'Alice' from pipeline	Hello, Alice!
2	"Bob"	Bob	Function receives 'Bob' from pipeline	Hello, Bob!
3	No more input	null	Pipeline ends, function stops processing	No output

💡 Pipeline input exhausted, no more objects to process.

Variable Tracker

Variable	Start	After 1	After 2	Final
$Name	null	Alice	Bob	null

Key Moments - 3 Insights

Why does the function process each input separately instead of all at once?

Because ValueFromPipeline passes one object at a time through the pipeline, as shown in execution_table steps 1 and 2 where each input triggers a separate function call.

What happens if the function parameter does not have ValueFromPipeline set to true?

The function will not accept pipeline input, so the pipeline objects won't be passed automatically, and the function won't process them as shown in the execution_table.

Why is the 'process' block used inside the function?

The 'process' block runs once for each pipeline input object, ensuring each input is handled individually, as seen in the step-by-step outputs.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of $Name at Step 2?

A null

B Alice

C Bob

D "Bob"

💡 Hint

Check the 'Parameter Value' column at Step 2 in the execution_table.

At which step does the pipeline input end?

A Step 3

B Step 2

C Step 1

D Never ends

💡 Hint

Look for the step where 'No more input' is noted in the 'Pipeline Input' column.

If ValueFromPipeline was set to false, what would happen to the output?

A Function would still output greetings for each name

B Function would output nothing from pipeline input

C Function would throw an error

D Function would output all names at once

💡 Hint

Refer to the key_moments explanation about ValueFromPipeline behavior.

Concept Snapshot

PowerShell functions can accept input from the pipeline using the ValueFromPipeline attribute.
Each object sent through the pipeline is passed one at a time to the function's process block.
Use the 'process' block to handle each input individually.
Without ValueFromPipeline, pipeline input is ignored.
This enables smooth chaining of commands and processing of streamed data.

Full Transcript

This example shows how a PowerShell function uses the ValueFromPipeline attribute to accept input from the pipeline. The function Show-Name takes a string parameter $Name marked with ValueFromPipeline=$true. When we pipe two names, "Alice" and "Bob", into Show-Name, PowerShell sends each name one by one to the function. Inside the process block, the function outputs a greeting for each name. The execution table traces each step: first processing "Alice", then "Bob", and finally ending when no more input is available. The variable tracker shows how $Name changes from null to Alice, then Bob, then back to null after processing. Key moments clarify why the process block is needed and what happens if ValueFromPipeline is not set. The visual quiz tests understanding of variable values and pipeline flow. This pattern is essential for writing PowerShell functions that work well with pipelines, making scripts modular and efficient.