CODEWITHSUNDEEP
powershell
pargit
pargit

Reputation: 23

Powershell pass command switches as variable

i'm trying to create a script that handle copy of folders and files. i need to pass the switches '-recures -container' if it's a folder and nothing is it's a file. is there a way to create a variable that will hold the '-recurse -container' and pass it to the command like this:

$copy_args = '-Recurse -container '
Copy-Item $tmptmp\$file -Destination \\$server\d$\$tmpprd\ $copy_args -Force

thanks Mor

Upvotes: 2

Views: 269

Answers (2)

mklement0
mklement0

Reputation: 439193

Mark Wragg's helpful answer recommends splatting, which gives you the most flexibility.

As an aside:

  • Setting -Recurse is sufficient in your case, because it implies -Container
  • In fact, you can even use -Recurse unconditionally, because it is simply ignored if the source path is a file.

On occasion you may want to conditionally pass a switch directly, without the added verbosity of splatting.

Given that the syntax - -SomeSwitch:$boolVar or -SomeSwitch:(<boolExpression>) (optionally with whitespace after :) - isn't obvious, let me demonstrate:

Using a Boolean variable:

# The source path.
$sourcePath = $tmptmp\$file

# Set the Boolean value that will turn the -Recurse switch on / off.
$doRecurse = Test-Path -PathType Container $sourcePath # $true if $sourcePath is a dir.

# Use -Recurse:$doRecurse
Copy-Item -Recurse:$doRecurse $sourcePath -Destination \\$server\d$\$tmpprd\ -Force

Alternatively, using a Boolean expression:

Copy-Item -Recurse:(Test-Path -PathType Container $sourcePath) $sourcePath -Destination \\$server\d$\$tmpprd\ -Force

Note that the : to separate the parameter name from the argument is a necessity in the case of a switch parameter, so as to indicate that the argument is intended for the switch (which normally do not take an argument) rather than being a separate, positional argument.

Caveat: Both in this case and with splatting passing an effective $false to a switch is technically not the same as omitting the switch, and there are situations where the difference matters.
Read on to learn more.

Technically, a cmdlet or advanced function can distinguish between an omitted switch and one with a $false argument via the automatic $PSBoundParameters variable, which contains a dictionary of all explicitly passed parameters.

In the case of the common -Confirm parameter, this distinction is used intentionally - which is atypical.

Here's a simple demonstration:

# Sample advanced function that supports -Confirm with a medium impact level.
function foo { 
  [CmdletBinding(SupportsShouldProcess, ConfirmImpact='Medium')]
  param() 

  if ($PSCmdlet.ShouldProcess('dummy')) { 'do it' }  
}

# Invocation *with -Confirm* prompts unconditionally.
foo -Confirm  # ditto with -Confirm:$true

# Invocation *without -Confirm*:
# Whether you'll be prompted depends on the value of the $ConfirmPreference
# variable: If the value is 'Medium' or 'Low', you'll be prompted.
foo

# Invocation with *-Confirm:$false* NEVER prompts,
# irrespective of the $ConfirmPreference value.
foo -Confirm:$false

Upvotes: 1

Mark Wragg
Mark Wragg

Reputation: 23385

The best way to do this is with a technique called splatting. You create a hashtable of the parameters you want to pass and then you use @ with the variable name (instead of $) to indicate that you want to splat it in to the required cmdlets parameters:

$copy_args = @{
     Recurse = $true
     Container = $true
}

Copy-Item $tmptmp\$file -Destination \\$server\d$\$tmpprd\ @copy_args -Force

Upvotes: 6

Related Questions