WhatIf and Confirm support in PowerShell - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the -WhatIf parameter do in PowerShell?

It shows what would happen if a command runs, without actually making any changes. It's like a preview or a dry run.

beginner

What is the purpose of the -Confirm parameter in PowerShell?

It asks you to confirm before running a command that changes something. You get a yes/no question to avoid mistakes.

intermediate

How do you add -WhatIf support to your own PowerShell function?

Add [CmdletBinding(SupportsShouldProcess=$true)] at the top and use $PSCmdlet.ShouldProcess() inside your function to check if it should run.

beginner

What happens if you run a command with -Confirm and answer 'No'?

The command stops and does not make any changes. This helps prevent unwanted actions.

beginner

Why is it good practice to support -WhatIf and -Confirm in scripts?

It helps users avoid mistakes by previewing changes and asking for confirmation, making scripts safer to run.

What does the -WhatIf parameter do when added to a PowerShell command?

A Shows what would happen without making changes

B Automatically confirms the command

C Runs the command silently

D Cancels the command immediately

-WhatIf previews the command's effect without changing anything.

Which attribute enables -WhatIf support in a PowerShell function?

A [CmdletBinding(SupportsShouldProcess=$true)]

B [Parameter(Mandatory=$true)]

C [OutputType([string])]

D [ValidateSet()]

This attribute tells PowerShell the function supports -WhatIf and -Confirm.

What does the $PSCmdlet.ShouldProcess() method do inside a function?

A Stops the script immediately

B Prints the command output

C Checks if the command should run based on <code>-WhatIf</code> or <code>-Confirm</code>

D Runs the command without confirmation

It checks if the user wants to proceed, respecting -WhatIf and -Confirm.

If you run a command with -Confirm and choose 'No', what happens?

A The command runs anyway

B The command runs silently

C The command runs twice

D The command does not run

Answering 'No' cancels the command to prevent changes.

Why should script authors add -WhatIf and -Confirm support?

A To hide script output

B To make scripts safer and prevent accidental changes

C To make scripts run faster

D To disable user interaction

These features help users avoid mistakes by previewing and confirming actions.

Explain how to add WhatIf and Confirm support to a PowerShell function.

Think about the attribute and method that enable this support.

Describe the difference between -WhatIf and -Confirm parameters in PowerShell.

One previews, the other asks permission.

Practice

1. What does the -WhatIf parameter do when used with a PowerShell command?

easy

A. It logs the command output to a file automatically.

B. It forces the command to run without any confirmation prompts.

C. It cancels the command immediately after starting.

D. It shows what the command would do without actually performing the action.

Solution

1. Step 1: Understand the purpose of -WhatIf

   The -WhatIf parameter simulates the command's effect without making changes.

2. Step 2: Compare options to the definition

   Only It shows what the command would do without actually performing the action. correctly describes this simulation behavior.

3. Final Answer:

   It shows what the command would do without actually performing the action. -> Option D

4. Quick Check:

   -WhatIf simulates action = D [OK]

Hint: WhatIf means "show only, don't do" [OK]

Common Mistakes:

• Thinking -WhatIf runs the command fully
• Confusing -WhatIf with -Confirm
• Assuming it cancels the command

2. Which of the following is the correct way to add confirmation support to a PowerShell function?

easy

A. Add [CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact='Medium')] above the function.

B. Add param([switch]$Confirm) inside the function body.

C. Use Write-Host 'Confirm?' inside the function.

D. Add -Confirm inside the function name.

Solution

1. Step 1: Recall how to enable Confirm support

   PowerShell functions use [CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact='Medium')] to support -WhatIf and -Confirm.

2. Step 2: Check each option

   Only Add [CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact='Medium')] above the function. correctly shows the attribute syntax to enable confirmation support.

3. Final Answer:

   Add [CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact='Medium')] above the function. -> Option A

4. Quick Check:

   Enable Confirm with CmdletBinding attribute = C [OK]

Hint: Use CmdletBinding attribute to enable Confirm support [OK]

Common Mistakes:

• Adding param switch instead of CmdletBinding
• Using Write-Host for confirmation prompts
• Trying to put -Confirm in function name

3. Given this function with Confirm support:

[CmdletBinding(SupportsShouldProcess=$true)]
function Remove-File {
  param([string]$Path)
  if ($PSCmdlet.ShouldProcess($Path)) {
    Remove-Item $Path
  }
}

What happens when you run Remove-File -Path 'test.txt' -WhatIf?

medium

A. It shows a message about deleting 'test.txt' but does not delete it.

B. It deletes 'test.txt' without asking.

C. It asks for confirmation before deleting 'test.txt'.

D. It throws an error because -WhatIf is not supported.

Solution

1. Step 1: Understand the function's use of ShouldProcess

   The function calls $PSCmdlet.ShouldProcess($Path), which respects -WhatIf and -Confirm.

2. Step 2: Effect of running with -WhatIf

   Using -WhatIf causes ShouldProcess to return false but show what would happen, so Remove-Item is not called.

3. Final Answer:

   It shows a message about deleting 'test.txt' but does not delete it. -> Option A

4. Quick Check:

   -WhatIf shows action, no delete = B [OK]

Hint: ShouldProcess respects -WhatIf to simulate actions [OK]

Common Mistakes:

• Assuming -WhatIf deletes files
• Confusing -WhatIf with -Confirm
• Thinking function lacks support for -WhatIf

4. You wrote this function:

function Delete-Data {
  param([string]$File)
  if ($PSCmdlet.ShouldProcess($File)) {
    Remove-Item $File
  }
}

But when you run Delete-Data -File 'data.txt' -Confirm, it does not ask for confirmation. Why?

medium

A. You must add -WhatIf to enable confirmation.

B. The function lacks [CmdletBinding(SupportsShouldProcess=$true)] attribute.

C. The param block is missing [switch]$Confirm parameter.

D. Remove-Item does not support confirmation.

Solution

1. Step 1: Check function attributes for Confirm support

   The function is missing [CmdletBinding(SupportsShouldProcess=$true)], which enables -Confirm and -WhatIf support.

2. Step 2: Understand effect of missing attribute

   Without this attribute, the function ignores -Confirm and does not prompt.

3. Final Answer:

   The function lacks [CmdletBinding(SupportsShouldProcess=$true)] attribute. -> Option B

4. Quick Check:

   Missing CmdletBinding disables Confirm = A [OK]

Hint: Add CmdletBinding to enable -Confirm prompts [OK]

Common Mistakes:

• Thinking -WhatIf enables confirmation
• Adding Confirm parameter manually
• Assuming Remove-Item disables confirmation

5. You want to write a PowerShell function that deletes files but only after confirmation, and also supports -WhatIf. Which code snippet correctly implements this?

hard

A. [CmdletBinding()]
function Remove-MyFile {
param([string]$Path)
Remove-Item $Path -Confirm
}

B. function Remove-MyFile {
param([string]$Path, [switch]$Confirm)
if ($Confirm) {
Remove-Item $Path
}
}

C. [CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact='High')]
function Remove-MyFile {
param([string]$Path)
if ($PSCmdlet.ShouldProcess($Path, 'Remove')) {
Remove-Item $Path
}
}

D. function Remove-MyFile {
param([string]$Path)
Remove-Item $Path -WhatIf
}

Solution

1. Step 1: Identify correct use of CmdletBinding and ShouldProcess

   [CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact='High')] function Remove-MyFile { param([string]$Path) if ($PSCmdlet.ShouldProcess($Path, 'Remove')) { Remove-Item $Path } } uses [CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact='High')] and calls $PSCmdlet.ShouldProcess, enabling both -Confirm and -WhatIf support.

2. Step 2: Check other options for missing or incorrect usage

   function Remove-MyFile { param([string]$Path, [switch]$Confirm) if ($Confirm) { Remove-Item $Path } } lacks CmdletBinding and misuses Confirm as a manual switch. [CmdletBinding()] function Remove-MyFile { param([string]$Path) Remove-Item $Path -Confirm } lacks SupportsShouldProcess and forces -Confirm on Remove-Item only. function Remove-MyFile { param([string]$Path) Remove-Item $Path -WhatIf } always uses -WhatIf, which is not correct for actual deletion.

3. Final Answer:

   [CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact='High')] with $PSCmdlet.ShouldProcess -> Option C

4. Quick Check:

   CmdletBinding + ShouldProcess = A [OK]

Hint: Use CmdletBinding and ShouldProcess for full Confirm and WhatIf [OK]

Common Mistakes:

• Forgetting CmdletBinding attribute
• Manually adding Confirm switch parameter
• Always using -WhatIf inside function