PowerShell Parameters Zero to Hero – Part1

PowerShell Parameters present a superb and simple approach to make the script extra dynamic and versatile for the customers and the proprietor’s wants by permitting the script to take motion based mostly on the handed worth. This makes the script shorter and far simpler for updates and bug fixes. Should you by no means wrote a PowerShell parameter, then no fear as this sequence takes you on a journey from zero to hero in PowerShell parameters.

We begin with a primary PowerShell script and step-by-step add extra options, PowerShell Capabilities, and PowerShell parameters. While you end studying this publish, you’ll have a transparent understanding of the PowerShell parameters, how you can write them, and a few finest practices.

Conditions

You should utilize Home windows PowerShell ISE to observe, however I extremely advocate utilizing PowerShell 7 with VSCode. PowerShell 7 and VSCode are free to obtain plus they work with most OS together with Linux and macOS

What primary PowerShell script seems to be like?

Earlier than begin explaining what’s PowerShell parameters, let’s see and begin with an everyday primary PowerShell script and use it as a place to begin in order that in a while we learn to make the PowerShell script extra versatile by utilizing PowerShell Parameters and PowerShell Capabilities.

The next PowerShell script will get the variety of gadgets in a folder referred to as Directory1, then copies the content material from Directory1 to Directory2. After that, it will get the variety of content material in Directory2 and shows the rely on the display.

let’s title this script as PSCopy.ps1

#Get Variety of Recordsdata within the supply folder
$NumberOfSourceFiles=Get-ChildItem -Path C:Directory1 -Recurse
Write-Host "The Variety of recordsdata in C:Directory1 : " -NoNewline
Write-Host  $($NumberOfSourceFiles.rely) -ForegroundColor Inexperienced
#Copy gadgets to Vacation spot folder
$NumberOfSourceFiles | Copy-Merchandise -Vacation spot "C:Directory2" -Pressure 
#Get Variety of file within the vacation spot folder
$NumberOfDestFiles=Get-ChildItem -Path C:Directory2 -Recurse
Write-Host "The Variety of recordsdata in C:Directory2 : " -NoNewline
Write-Host  $($NumberOfDestFiles.rely) -ForegroundColor Inexperienced

Save the PowerShell script after which begin it. When the script begins, the output of this script seems to be like this.

All seems to be fantastic, the PowerShell script did what it ought to do. However did you discover the variety of hard-coded values which might be represented by the listing paths C:Directory1 and C:Directory2 and the variety of instances these values are repeated?!

Altering the listing’s paths or construction takes a very long time, and in addition it’s potential to neglect to replace some values contained in the script. So let’s begin studying the fundamentals required to make the most of PowerShell parameters.

Defining PowerShell Parameters

To make this script extra versatile for the consumer, the customers ought to be capable to specify the supply and vacation spot folder with out having to edit the PowerShell Script and alter these values manually.

To create a PowerShell parameter we use the Param key phrase. The Param block is outlined by utilizing opening and shutting parentheses (). When typing the Param, ensure it’s written on the high of the PowerShell script. Let’s see it in motion.

The PowerShell parameter title may be no matter you need prepended with a $, it’s truly a variable, identical means.

Within the following instance, a parameter named FirstParameter is outlined.

Param( # Param keywork on the highest adopted by an opened parentheses
$FirstParameter  #<---------- That is the Parameter
) #The top of Param block

#The remainder of the code
Write-Host "The consumer Typed: $($FirstParameter)"

Save the script and provides it no matter title you want, I used 1stparam.ps1. Executing this script like the next

PS C:> .1stparam.ps1 -FirstParameter "Param1"

Right here is how the output seems to be like

The consumer Typed: Param1

Comply with these steps to put in writing your first PowerShell parameter:

• The code block began with the phrase Param after which an open parentheses
• Write the parameter title as a variable.
• Shut the parentheses

So within the instance above, the consumer passes Param1 for the FirstParameter parameter. PowerShell assigns Param1 to FirstParameter and reveals the end result.

When calling PowerShell parameter utilizing any IDE, an inventory will popup with the out there parameters after typing the cmdlet title adopted by house. However when utilizing the PowerShell console, you should utilize the CTRL+House bar after typing the - to checklist the out there parameters.

Defining Extra Than One PowerShell Parameter

There’s a small trick it is advisable look ahead to. When you’ve got multiple parameter, it is advisable add a comma , on the finish of every parameter title besides the final one. However in case you have just one parameter no want so as to add any comma on the finish of the parameter title.

Verify the earlier 1stParam.ps1 instance and see how the PowerShell parameter decleared, there was no comma on the finish of the parameter title.

Let’s have one other instance and add a further two parameters.

Param( # Param keywork on the highest adopted by an opened parentheses
$FirstParameter,  
$SecondParameter, #All of the parameter should have comma "," on the finish of the parameter title
$ThirdParameter  # Besides the final parameter there isn't any comma "," on the finish
)#The top of Param scope

#The remainder of the code
Write-Host "First Parameter worth: $($FirstParameter)" 
Write-Host "Second Parameter worth: $($FirstParameter)"
Write-Host "Third Parameter worth: $($FirstParameter)" 

As you’ll be able to see all of the parameters ends with a comma “,” besides the final one. So FirstParameter and SecondParameter have comma “,” on the finish of the parameter title, however the ThirdParameter doesn’t. The identical applies in case you have two or extra parameters.

PowerShell Parameter finest practices – Half 1

For now, attempt to observe these factors as the perfect practices:

• Use a significant full parameter title. for instance, use ComputerName as an alternative of PC, or CN and even Pc. Preserve your parameter readable and provides the consumer the power to grasp what they should sort.
• Don’t use a really lengthy parameter title. for instance, don’t use TypeHereTheComputerNameForYourMachine

Extra ideas and finest practices are on the best way.

Utilizing PowerShell Parameter inside PowerShell Perform

PowerShell Perform Fundamentals

Consider a PowerShell script that should do an analogous job a number of instances through the runtime, akin to displaying an error message on the display with some particulars. There are two potential methods. You’ll be able to write the identical code a number of instances as required or just use the PowerShell perform to wrap the block of code, give it a reputation, and name it when required.

Capabilities make the code shorter, stop repetitive code, and preserve the code simpler to grasp and replace.

PowerShell perform begins with the phrase Perform then the title of the perform, which may be no matter you need, and a block of code in a gap and shutting curly brackets { }.

Sure you should utilize any title for the Perform, however its advocate to make use of the authorised verbs as listed in Microsoft so as an alternative of naming a perform Show-ErrorMessage, make it Present-ErrorMessage

We are going to undergo the fundamentals of perform and how you can add PowerShell parameters to it. PowerShell perform seems to be like this

Perform NameOfFunction {
#Block of Code
}

Don’t get confused between the parameter and performance brackets, the Param makes use of parentheses ( ) however the perform makes use of curly brackets { }

Within the subsequent instance, PowerShell rely from 0 to 10, and with every quantity, PowerShell executes the Present-MyMessage code block, which is the perform.

Perform Present-MyMessage {
    Write-Host "Inside Perform Code Began at " -NoNewLine
    Get-Date
    }
for ($i = 0; $i -lt 10; $i++) {
    Write-Host "My counting is $($i)"
    Present-MyMessage
    Write-Host "Remaining code contained in the script"
}

PS C:> My counting is 0
Inside Perform Code Began at
Tuesday, Might 10, 2022 9:50:23 AM
Remaining code contained in the script
My counting is 1
Inside Perform Code Began at Tuesday, Might 10, 2022 9:50:23 AM
Remaining code contained in the script
My counting is 2
Inside Perform Code Began at Tuesday, Might 10, 2022 9:50:23 AM
Remaining code contained in the script
My counting is 3
Inside Perform Code Began at Tuesday, Might 10, 2022 9:50:23 AM
Remaining code contained in the script
My counting is 4
Inside Perform Code Began at Tuesday, Might 10, 2022 9:50:23 AM
Remaining code contained in the script
My counting is 5
Inside Perform Code Began at Tuesday, Might 10, 2022 9:50:23 AM
Remaining code contained in the script
My counting is 6
Inside Perform Code Began at Tuesday, Might 10, 2022 9:50:23 AM
Remaining code contained in the script
My counting is 7
Inside Perform Code Began at Tuesday, Might 10, 2022 9:50:23 AM
Remaining code contained in the script
My counting is 8
Inside Perform Code Began at Tuesday, Might 10, 2022 9:50:23 AM
Remaining code contained in the script
My counting is 9
Inside Perform Code Began at Tuesday, Might 10, 2022 9:50:23 AM
Remaining code contained in the script

Including Parameter to the perform

PowerShell features don’t solely make the code shorter and simpler to replace as talked about earlier than, however they’re additionally versatile and settle for parameters.

When including parameters to the perform, the perform is named from contained in the script utilizing the identical methodology of calling a parameter by utilizing the - image and offering the parameter title and its worth.

To begin, use the parameter key phrase Param() contained in the perform. The Param() key phrase is positioned just under the perform phrase.

Within the earlier instance, Present-MyMessage.ps1, the Present-MyMessage perform output “Inside Perform Code Began at“. Let’s replace it so a personalized message is displayed within the output. This personalized message is handed from the script block to the perform as a parameter.

Perform Present-MyMessage{ # <------ Perform Begin right here
Param ( # <---------- Parameter begin right here 
$NewMessage # <----- Parameter Identify
) # <---- Finish of Parameter Block
### the remainding Code of the perform block
} # <------ Perform Closure

Present-MyMessage #Name the Perform title to execute the Perform code block.
# Remainder of PowerShell script.

Perform Present-MyMessage { # <--- Perform begin
    Param ( # <--- Parameter Begin
     $Message # <--- Parameter title
    ) # <--- Parameter block end
    Write-Host "Perform Block Began" -ForegroundColor Yellow
    Write-Host $Message # <--- The worth of $Message is from the script block line 12
    Get-Date
    } # <--- Perform completed

for ($i = 0; $i -lt 10; $i++) {
    Write-Host "Script Block $($i)" -ForegroundColor Blue
    Present-MyMessage -Message "Debug For $($i) "
}

The output of the script, and see how we handle to cross the textual content “Debug For $($i)” to the perform and the perform parameter.

PowerShell referred to as the Present-MyMessage.ps1 perform with its parameter -Message and passes the worth.

Abstract

With this fast half one in every of this sequence, you learn to declare PowerShell parameters to your script and performance. There’s nonetheless lots to come back. Within the subsequent publish, I’ll clarify how you can make the PowerShell parameter obligatory and another fundamentals.