Parameters in PowerShell - Step-by-Step Execution

Concept Flow - Parameters

Start Script

↓

Define Function with Parameters

↓

Call Function with Arguments

↓

Parameters Receive Values

↓

Function Executes Using Parameters

↓

Output Result

↓

End Script

The script defines a function with parameters, then calls it with arguments. The parameters receive the values and the function runs using them, producing output.

Execution Sample

PowerShell

function Greet-User {
  param($name)
  "Hello, $name!"
}

Greet-User -name "Alice"

This script defines a function that takes a name parameter and prints a greeting using that name.

Execution Table

Step	Action	Parameter 'name' Value	Output
1	Function Greet-User defined with parameter 'name'	null
2	Function called with argument -name 'Alice'	Alice
3	Inside function, output string created using parameter	Alice	Hello, Alice!
4	Function returns output	Alice	Hello, Alice!

💡 Function completes after returning the greeting string.

Variable Tracker

Variable	Start	After Call	Final
name	null	Alice	Alice

Key Moments - 2 Insights

Why does the parameter 'name' have the value 'null' before the function is called?

Before the function is called, the parameter 'name' does not have a value. It only gets assigned when the function is called with an argument, as shown in step 2 of the execution table.

What happens if you call the function without providing the parameter?

If you call the function without the parameter, 'name' will be null or empty inside the function, so the output will be 'Hello, !' or an error if the script expects a value. This is because parameters get their values only from the call.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'name' at step 2?

A Alice

B null

C Hello, Alice!

D Empty string

💡 Hint

Check the 'Parameter 'name' Value' column at step 2 in the execution table.

At which step does the function produce the output 'Hello, Alice!'?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at the 'Output' column in the execution table to find when the greeting is created.

If you call the function without any argument, how would the 'name' variable change in the variable tracker?

A It becomes an error value

B It becomes 'Alice'

C It stays null after call

D It becomes an empty string

💡 Hint

Parameters get their value only when arguments are passed, see variable_tracker for how 'name' changes.

Concept Snapshot

Parameters let you send values into functions.
Define parameters with 'param()' inside the function.
Call the function with arguments to fill parameters.
Inside the function, use parameters like variables.
If no argument is passed, parameter is null or default.
Parameters make functions flexible and reusable.

Full Transcript

This visual execution shows how parameters work in PowerShell functions. First, the function Greet-User is defined with a parameter called 'name'. When the function is called with the argument 'Alice', the parameter 'name' receives this value. Inside the function, the greeting string uses the parameter to create 'Hello, Alice!'. The function then outputs this greeting. The variable tracker shows 'name' starts as null and changes to 'Alice' after the call. Key moments clarify that parameters only get values when the function is called, and calling without arguments leaves parameters null. The quiz tests understanding of parameter values and output timing.

Practice

1. What is the purpose of using param() in a PowerShell script?

easy

A. To declare input parameters that the script can accept

B. To define a function inside the script

C. To output results from the script

D. To comment lines in the script

Solution

1. Step 1: Understand the role of param()

   The param() block is used at the start of a PowerShell script to declare parameters that the script can accept as input.

2. Step 2: Differentiate from other script parts

   It is not used to define functions, output results, or comment lines. Those have different syntax and purposes.

3. Final Answer:

   To declare input parameters that the script can accept -> Option A

4. Quick Check:

   param() declares input parameters [OK]

Hint: Remember: param() is for input, not output or comments [OK]

Common Mistakes:

• Confusing param() with function declaration
• Thinking param() outputs data
• Using param() to comment code

2. Which of the following is the correct syntax to declare a mandatory string parameter named Name in PowerShell?

easy

A. param([string]$Name = "")

B. param([string]$Name)

C. param($Name:string Mandatory)

D. param([Parameter(Mandatory=$true)][string]$Name)

Solution

1. Step 1: Understand mandatory parameter syntax

   To make a parameter mandatory, use the [Parameter(Mandatory=$true)] attribute before the type and name.

2. Step 2: Check each option

   param([Parameter(Mandatory=$true)][string]$Name) correctly uses [Parameter(Mandatory=$true)][string]$Name. param([string]$Name = "") sets a default empty string, so not mandatory. param([string]$Name) lacks the mandatory attribute. param($Name:string Mandatory) is invalid syntax.

3. Final Answer:

   param([Parameter(Mandatory=$true)][string]$Name) -> Option D

4. Quick Check:

   Mandatory parameter needs [Parameter(Mandatory=$true)] [OK]

Hint: Mandatory parameters use [Parameter(Mandatory=$true)] attribute [OK]

Common Mistakes:

• Omitting the Mandatory attribute
• Using default value instead of mandatory
• Incorrect attribute syntax

3. What will be the output of this script when run with -Count 3?

param([int]$Count = 1)
for ($i = 1; $i -le $Count; $i++) { Write-Output "Number $i" }

medium

A. Number 1
Number 2
Number 3

B. Number 1

C. Number 3

D. Error: Missing parameter

Solution

1. Step 1: Understand parameter default and input

   The parameter $Count has a default of 1 but is overridden by passing -Count 3.

2. Step 2: Trace the loop output

   The for loop runs from 1 to 3, outputting "Number 1", "Number 2", and "Number 3" each on a new line.

3. Final Answer:

   Number 1 Number 2 Number 3 -> Option A

4. Quick Check:

   Loop runs 3 times with Count=3 [OK]

Hint: Parameter overrides default; loop runs Count times [OK]

Common Mistakes:

• Ignoring passed parameter and using default
• Expecting single output instead of looped output
• Confusing parameter name or type

4. Identify the error in this parameter declaration:

param([int]$Age = "twenty")

medium

A. Missing mandatory attribute

B. Type mismatch: assigning string to int parameter

C. Parameter name cannot be Age

D. Default value must be null

Solution

1. Step 1: Check parameter type and default value

   The parameter $Age is declared as [int] but the default value is the string "twenty".

2. Step 2: Understand type mismatch error

   PowerShell cannot convert the string "twenty" to an integer, causing a type mismatch error.

3. Final Answer:

   Type mismatch: assigning string to int parameter -> Option B

4. Quick Check:

   Default value must match parameter type [OK]

Hint: Default values must match declared parameter type [OK]

Common Mistakes:

• Assigning string default to int parameter
• Ignoring type mismatch errors
• Assuming parameter name restrictions

5. You want to create a script that accepts two parameters: Path (string, mandatory) and Verbose (switch, optional). Which is the correct way to declare these parameters?

hard

A. param([string]$Path, [Parameter(Mandatory=$true)][switch]$Verbose)

B. param([string]$Path = "", [switch]$Verbose = $false)

C. param([Parameter(Mandatory=$true)][string]$Path, [switch]$Verbose)

D. param([switch]$Path, [string]$Verbose)

Solution

1. Step 1: Identify mandatory and optional parameters

   Path must be mandatory string, so use [Parameter(Mandatory=$true)][string]$Path. Verbose is an optional switch, so [switch]$Verbose without mandatory attribute.

2. Step 2: Evaluate each option

   param([Parameter(Mandatory=$true)][string]$Path, [switch]$Verbose) correctly declares Path as mandatory string and Verbose as optional switch. param([string]$Path, [Parameter(Mandatory=$true)][switch]$Verbose) wrongly makes Verbose mandatory. param([string]$Path = "", [switch]$Verbose = $false) sets default empty string for Path, so not mandatory. param([switch]$Path, [string]$Verbose) swaps types incorrectly.

3. Final Answer:

   param([Parameter(Mandatory=$true)][string]$Path, [switch]$Verbose) -> Option C

4. Quick Check:

   Mandatory string + optional switch = param([Parameter(Mandatory=$true)][string]$Path, [switch]$Verbose) [OK]

Hint: Mandatory uses [Parameter(Mandatory=$true)], switches don't [OK]

Common Mistakes:

• Making switches mandatory
• Setting default values instead of mandatory
• Mixing parameter types