Command Types
When a command is executed
in PowerShell, the command interpreter looks at the command name to
figure out what task to perform. This process includes determining the
type of command and how to process that command. There are four types of
PowerShell commands: cmdlets, shell function commands, script commands,
and native commands.
cmdlet
The first command type is a
cmdlet (pronounced “command-let”), which is similar to the built-in
commands in other CLI-based shells. The difference is that cmdlets are
implemented by using .NET classes compiled into a dynamic link library
(DLL) and loaded into PowerShell at runtime. This difference means
there’s no fixed class of built-in cmdlets; anyone can use the
PowerShell Software Developers Kit (SDK) to write a custom cmdlet, thus
extending PowerShell’s functionality.
A cmdlet is always named as a
verb and noun pair separated by a “-” (hyphen). The verb specifies the
action the cmdlet performs, and the noun specifies the object being
operated on. An example of a cmdlet being executed is shown as follows:
PS C:\> Get-Process
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
425 5 1608 1736 90 3.09 428 csrss
79 4 1292 540 86 1.00 468 csrss
193 4 2540 6528 94 2.16 2316 csrss
66 3 1128 3736 34 0.06 3192 dwm
412 11 13636 20832 125 3.52 1408 explorer
...
While executing cmdlets in PowerShell, you
should take a couple of considerations into account. Overall, PowerShell
was created such that it is both forgiving and easy when it comes to
syntax. In addition, PowerShell also always attempts to fill in the
blanks for a user. Examples of this are illustrated in the following
items:
Cmdlets are always
structured in a nonplural verb-noun format.
Parameters and arguments are positional: Get-Process
winword.
Many arguments can use
wildcards: Get-Process w*.
Partial
parameter names are also allowed: Get-Process –P w*.
Note
When executed, a cmdlet only
processes a single record at a time.
Functions
The next type of command is a
function. These commands provide a way to assign a name to a list of
commands. Functions are similar to subroutines and procedures in other
programming languages. The main difference between a script and a
function is that a new instance of the shell is started for each shell
script, and functions run in the current instance of the same shell.
Note
Functions defined at the
command line remain in effect only during the current PowerShell
session. They are also local in scope and don’t apply to new PowerShell
sessions.
Although a function defined
at the command line is a useful way to create a series of commands
dynamically in the PowerShell environment, these functions reside only
in memory and are erased when PowerShell is closed and restarted.
Therefore, although creating complex functions dynamically is possible,
writing these functions as script commands might be more practical. An
example of a shell function command is as follows:
PS C:\> function showFiles {Get-ChildItem}
PS C:\> showfiles
Directory: Microsoft.PowerShell.Core\FileSystem::C:\
Mode LastWriteTime Length Name
---- ------------- ------ ----
d---- 9/4/2007 10:36 PM inetpub
d---- 4/17/2007 11:02 PM PerfLogs
d-r-- 9/5/2007 12:19 AM Program Files
d-r-- 9/5/2007 11:01 PM Users
d---- 9/14/2007 11:42 PM Windows
-a--- 3/26/2007 8:43 PM 24 autoexec.bat
-ar-s 8/13/2007 11:57 PM 8192 BOOTSECT.BAK
-a--- 3/26/2007 8:43 PM 10 config.sys
Advanced Functions
Advanced functions are a new feature that was
introduced in PowerShell v2.0. The basic premise behind advanced
functions is to enable administrators and developers access to the same
type of functionality as a compiled cmdlet, but directly through the
PowerShell scripting language. An example of an advanced function is as
follows:
function SuperFunction {
<#
.SYNOPSIS
Superduper Advanced Function.
.DESCRIPTION
This is my Superduper Advanced Function.
.PARAMETER Message
Message to write.
#>
param(
[Parameter(Position=0, Mandatory=$True, ValueFromPipeline=$True)]
[String] $Message
)
Write-Host $Message
}
You
will see that one of the major identifying aspects of an advanced
function is the use of the CmdletBinding attribute. Usage of this attribute in an advanced
function allows PowerShell to bind the parameters in the same manner
that it binds parameters in a compiled cmdlet. For the SuperFunction
example, CmdletBinding is used to define the $Message parameter with position 0, as mandatory, and is
able to accept values from the pipeline. For example, the following
shows the SuperFunction being executed, which then prompts for a message
string. That message string is then written to the console:
PS C:\Users\tyson> SuperFunction
cmdlet SuperFunction at command pipeline position 1
Supply values for the following parameters:
Message: yo!
yo!
Finally,
advanced functions can also use all of the methods and properties of
the PSCmdlet class, for example:
Usage of all
the input processing methods (Begin, Process, and End)
Usage of the ShouldProcess and ShouldContinue methods, which can be used to get user
feedback before performing an action
Usage of the ThrowTerminatingError method, which can be used to generate error records
Usage of a various number
of Write methods
Scripts
Scripts, the third
command type, are PowerShell commands stored in a .ps1 file. The main difference from functions is
that scripts are stored on disk and can be accessed any time, unlike
functions that don’t persist across PowerShell sessions.
Scripts can be run in a
PowerShell session or at the cmd command prompt. To run a script in a
PowerShell session, type the script name without the extension. The
script name can be followed by any parameters. The shell then executes
the first .ps1 file matching the typed name in any of the paths located
in the PowerShell $ENV:PATH variable.
To run a PowerShell script from a
cmd command prompt, first use the CD command to change to the directory
where the script is located. Then run the PowerShell executable with
the command parameter and specifying which script to be run, as shown
here:
C:\Scripts>powershell -command .\myscript.ps1
If you don’t want to change
to the script’s directory with the cd
command, you can also run it by using an absolute path, as shown in this
example:
C:\>powershell -command C:\Scripts\myscript.ps1
An important detail
about scripts in PowerShell concerns their default security
restrictions. By default, scripts are not enabled to run as a method of
protection against malicious scripts. You can control this policy with
the Set-ExecutionPolicy cmdlet.
Native Commands
The last type of command, a
native command, consists of external programs that the operating system
can run. Because a new process must be created to run native commands,
they are less efficient than other types of PowerShell commands. Native commands
also have their own parameters for processing commands, which are
usually different from PowerShell parameters.
