WhatIf and Confirm support in PowerShell - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to enable WhatIf support for the Remove-Item cmdlet.

PowerShell

Remove-Item -Path 'C:\Temp\test.txt' [1]

Drag options to blanks, or click blank then click option'

A-Force

B-Confirm

C-WhatIf

D-Recurse

Attempts:

3 left

💡 Hint

Common Mistakes

Using -Confirm instead of -WhatIf shows a prompt instead of a simulation.

Using -Force or -Recurse does not simulate the action.

The -WhatIf parameter shows what would happen if the command runs, without making changes.

2fill in blank

medium

Complete the code to prompt for confirmation before deleting a file.

PowerShell

Remove-Item -Path 'C:\Temp\data.log' [1]

Drag options to blanks, or click blank then click option'

A-Force

B-WhatIf

C-Verbose

D-Confirm

Attempts:

3 left

💡 Hint

Common Mistakes

Using -WhatIf only simulates the action without prompting.

Using -Force bypasses confirmation prompts.

The -Confirm parameter asks for user confirmation before running the command.

3fill in blank

hard

Fix the error in the function to support WhatIf and Confirm parameters correctly.

PowerShell

function Remove-MyFile {
    param(
        [string]$Path
    )
    Remove-Item -Path $Path [1]
}

Drag options to blanks, or click blank then click option'

A-WhatIf:$true -Confirm:$true

B-Confirm

C-WhatIf

D-Force

Attempts:

3 left

💡 Hint

Common Mistakes

Using only -WhatIf or -Confirm without values inside a function.

Using -Force disables confirmation and simulation.

To support both WhatIf and Confirm, you must pass them as parameters with values.

4fill in blank

hard

Fill both blanks to add WhatIf and Confirm support to this advanced function.

PowerShell

function Remove-MyFolder {
    param(
        [string]$FolderPath,
        [switch]$WhatIf,
        [switch]$Confirm
    )
    Remove-Item -Path $FolderPath [1] [2]
}

Drag options to blanks, or click blank then click option'

A-WhatIf:$WhatIf

B-Confirm:$Confirm

C-Force

D-Recurse

Attempts:

3 left

💡 Hint

Common Mistakes

Hardcoding -WhatIf or -Confirm without using the parameters.

Forgetting to pass both parameters.

Pass the switches as parameter values to enable WhatIf and Confirm support dynamically.

5fill in blank

hard

Fill all three blanks to create a function that supports WhatIf and Confirm and uses them in Remove-Item.

PowerShell

function Remove-ItemSafe {
    param(
        [string]$TargetPath,
        [switch]$WhatIf,
        [switch]$Confirm
    )
    Remove-Item [1] [2] [3]
}

Drag options to blanks, or click blank then click option'

A-Path $TargetPath

B-Confirm:$Confirm

C-WhatIf:$WhatIf

D-Force

Attempts:

3 left

💡 Hint

Common Mistakes

Not passing the path parameter correctly.

Mixing up the order of parameters.

Not using the switch values with :$ syntax.

Pass the path and the switches $WhatIf and $Confirm to Remove-Item to support simulation and confirmation.

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