{"id":14071,"date":"2011-05-01T00:01:00","date_gmt":"2011-05-01T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2011\/05\/01\/best-practice-for-using-aliases-in-powershell-scripts\/"},"modified":"2011-05-01T00:01:00","modified_gmt":"2011-05-01T00:01:00","slug":"best-practice-for-using-aliases-in-powershell-scripts","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/best-practice-for-using-aliases-in-powershell-scripts\/","title":{"rendered":"Best Practice for Using Aliases in PowerShell Scripts"},"content":{"rendered":"

Summary<\/b>: Microsoft Scripting Guy, Ed Wilson, discusses the use of aliases in Windows PowerShell scripts. He covers the pros and cons in this blog.<\/p>\n

Weekend Scripter <\/h3>\n

Microsoft Scripting Guy, Ed Wilson, is here. “You can have my aliases when you pry my cold dead fingers from my keyboard,” was not one of the emails I received during the 2011 Scripting Games, but it easily could have been. It seems that in the world of Windows PowerShell, two things really seem to cause a lot of heated discussions—one is the use of aliases and the other is what goes in a profile. These two topics can overlap, but for now, I will focus on aliases. <\/p>\n

In general, I believe it is a best practice not to use aliases in a script. I also believe it is OK—in fact, I encourage the use of aliases at the Windows PowerShell prompt when one is working in an interactive fashion. Of course, part of the decision point around this depends on the definition of “best.” What do I mean by best?<\/p>\n

Here is a scenario to describe one view of best. A couple of weeks ago, the southeastern portion of the United States was hit by massive thunderstorms. Charlotte, North Carolina, unfortunately, was hit with this storm. In the image below, Dr. Scripto assists with cleanup in the aftermath of “The storm that tried to eat the 2011 Scripting Games.”<\/p>\n

\"Image<\/a><\/p>\n

As luck would have it, this was during the middle of the 2011 Scripting Games. If you follow ScriptingGuys on Twitter, you know that the Scripting Wife and I were without electricity for more than 25 hours (as were over 100,000 other people, so it was not some kind of conspiracy to keep the Scripting Wife from getting her scripts entered on time). <\/p>\n

It is 2:00 in the morning and the Scripting Wife wakes me up.<\/p>\n

“Can you make that UPS shut up,” she asks.<\/p>\n

“Mmmmmrrrrr umph,” I reply in somewhat incoherent speech.<\/p>\n

“Come on, wake up. That beeping is driving me crazy,” she complains.<\/p>\n

“Huh? Oh, all right,” I say. <\/p>\n

The house is completely dark. I grab a flashlight (a “torch” for my friends in the UK), and I tell the Scripting Wife to come with me into the office. I shake the mouse on my desktop to cause it wake up. I open the Windows PowerShell ISE, and I begin to write a script to shut down all 12 computers that are on my home network.<\/p>\n

“Hmmm, I say to myself. I think I will query AD with the AdsiSearcher and do a nice LDAP query to retrieve computer objects.” <\/p>\n

NOT!<\/p>\n

I open the Windows PowerShell console as an Administrator and type the command that is shown here.<\/p>\n

\n

Stop-Computer $mycomputers -force<\/span><\/span><\/span><\/p>\n<\/blockquote>\n

That is it. One reason is that I have a variable in my Windows PowerShell profile that performs the following command.<\/p>\n

\n

$mycomputers = Get-Content –path c:\\fso\\mycomputers.txt<\/span><\/span><\/span><\/p>\n<\/blockquote>\n

Although it is true that I have two pretty big UPSs in my office to support my twelve computers, networking equipment, and monitor, I am not certain of exactly how long they will keep everything up. In my mind, two o’clock in the morning, during a massive thunderstorm is not the time to be conducting load tests on my power supplies. It is true that I might very well need to run that command again—in fact, with our electric power supplier, it is a virtual certainty I will need the command again, but code reuse was not my top priority at that time. I did not use any aliases in my command; but then, there is no default alias for the Stop-Computer<\/b> cmdlet. There is nothing to keep one from creating an alias for it. However, I am considering really simplifying things and adding a new function to my profile. It is shown here. <\/p>\n

Stop-MyComputers Function<\/b><\/p>\n

\n

Function Stop-MyComputers<\/span><\/span><\/span><\/p>\n

{<\/span><\/span><\/span><\/p>\n

 <\/span><\/span>Stop-Computer -ComputerName $mycomputers -Force<\/span><\/span><\/span><\/span><\/p>\n

} #end function Stop-MyComputers<\/span><\/span><\/span><\/p>\n

 <\/span><\/span><\/span><\/p>\n

Set-Alias -Name sac -Value Stop-MyComputers -Description “Shutdown all computers”<\/span><\/span><\/span><\/p><\/blockquote>\n

When do I use aliases?<\/h4>\n

The previous function and alias combine to form one of my favorite things to do…I love to create a function with a descriptive name, and then create an alias for that function to facilitate using it from the Windows PowerShell console. Now, if a huge storm brews up in the sky, I can shut down my entire network with three key strokes—that is pretty quick. Of course, the function assumes that I will have a $mycomputers <\/i>variable, but that is defined inside my profile in the same location that the Stop-MyComputers<\/b> function will reside, so using the variable is a safe bet. <\/p>\n

The only trick is to remember to update the mycomputers.txt file when I add a new computer to the network. Another approach is to query AD in your profile and use the results of your query to populate the $mycomputers <\/i>variable. I might make that change one of these days. If I do, I will probably create three variables: $mycomputers, $myServers, <\/i>and $myvirtualmachines<\/i>. I might also create $allcomputers,<\/i> which would be created by adding the three previous variables. <\/p>\n

OK, so I got off on a bit of a tangent. Blame it on Boz Scaggs—I am listening to Boz Scaggs on my (soon to be extinct) Zune HD (I am heartbroken), and I guess I let my train of thought shuffle off to Toledo. Oh well.<\/p>\n

I was talking about the use of aliases. Largely I believe that it is a best practice to use aliases when working interactively at the Windows PowerShell console. I feel that when working interactively at the Windows PowerShell console, the goal is to accomplish something specific. This might not always be the case, and at times, I am simply experimenting, playing, or otherwise trying out various commands. In these scenarios, I do not feel too invested in the particular command, and I wish to try out many commands in a short amount of time. Aliases help and support these goals. <\/p>\n

When to not use aliases<\/h4>\n

When might I not want to type a series of aliases at the Windows PowerShell console? I can think of at least three scenarios. The first scenario involves typing a critical command or two. If I am getting ready to type a critical command, I want to be sure I am getting the syntax correct. Therefore, I will use the full cmdlet name, and I will use all of the named parameters. I will not rely on positional parameters. <\/p>\n

Another scenario in which I do not use aliases at the Windows PowerShell console involves what I call command prototyping. In this scenario, I am trying to figure out the syntax of a series of commands that I will use in a Windows PowerShell script. I have the Windows PowerShell ISE opened as well as the Windows PowerShell console. I will run my Windows PowerShell commands in the console until they are performing exactly the way I intend, and then I copy the command into my script in the Windows PowerShell ISE. Because I am copying directly from the Windows PowerShell console into my script, I use tab expansion to expand the complete cmdlet name and to avoid using aliases. For me this is less work than replacing the aliases in my script code after the fact. <\/p>\n

The third scenario is when I am teaching or making a presentation to customers. One of my pet peeves is Windows PowerShell presentations that are heavy with aliases…especially when the target audience is beginners. I believe it is extremely unfair to expect a novice user to come up to speed immediately with the intricacies of Windows PowerShell code and to learn 138 aliases for 236 cmdlets all at the same time. (I used the following commands to retrieve this information. The alias for Get-Alias<\/b> is gal<\/b>, and the alias for Get-Command<\/b> is gcm<\/b>.)<\/p>\n

\n

PS C:\\> gal | measure<\/span><\/span><\/span><\/p>\n

 <\/span><\/span><\/span><\/p>\n

Count    <\/span>: 138<\/span><\/span><\/span><\/p>\n

Average  <\/span>:<\/span><\/span><\/span><\/p>\n

Sum      <\/span>:<\/span><\/span><\/span><\/p>\n

Maximum  <\/span>:<\/span><\/span><\/span><\/p>\n

Minimum  <\/span>:<\/span><\/span><\/span><\/p>\n

Property :<\/span><\/span><\/span><\/p>\n

 <\/span><\/span><\/span><\/p>\n

PS C:\\> gcm -command cmdlet | measure<\/span><\/span><\/span><\/p>\n

 <\/span><\/span><\/span><\/p>\n

Count    <\/span>: 236<\/span><\/span><\/span><\/p>\n

Average  <\/span>:<\/span><\/span><\/span><\/p>\n

Sum      <\/span>:<\/span><\/span><\/span><\/p>\n

Maximum  <\/span>:<\/span><\/span><\/span><\/p>\n

Minimum  <\/span>:<\/span><\/span><\/span><\/p>\n

Property :<\/span><\/span><\/span><\/p>\n<\/blockquote>\n

Why worry about aliases in the first place?<\/h4>\n

What is the big deal about using aliases anyway? If they make the code easier to type, what is the harm in using them in scripts? There are two things at work when it comes to a script. The first is that no alias is guaranteed to exist—even aliases that are created by Windows PowerShell. There are two classes (or types) of aliases in Windows PowerShell. The first alias type is those that are marked Read-only. The following command displays the Read-only aliases. (The alias for Get-Alias<\/b> is gal<\/b>, the ? <\/b>is an alias for the Where-Object<\/b>, and ft<\/b> is an alias for the Format-Table<\/b> cmdlet. The –a<\/b> uses partial parameter completion for the autosize<\/b> switch.)<\/p>\n

\n

PS C:\\> gal | ? { $_.options -match ‘readonly’ } | ft name, options -a<\/span><\/span><\/span><\/p>\n

 <\/span><\/span><\/span><\/p>\n

Name               <\/span>Options<\/span><\/span><\/span><\/p>\n

—-               <\/span>——-<\/span><\/span><\/span><\/p>\n

%       <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

?       <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

ac      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

asnp    <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

clc     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

clhy    <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

cli     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

clp     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

clv     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

compare ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

cpi     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

cpp     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

cvpa    <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

dbp     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

diff    <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

ebp     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

epal    <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

epcsv   <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

fc      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

fl      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

foreach ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

ft      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

fw      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

gal     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

gbp     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

gc      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

gci     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

gcm     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

gcs     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

gdr     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

ghy     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

gi      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

gl      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

gm      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

gmo     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

gp      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

gps     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

group   <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

gsnp    <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

gsv     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

gu      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

gv      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

gwmi    <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

iex     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

ihy     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

ii      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

ipal    <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

ipcsv   <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

ipmo    <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

ise     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

iwmi    <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

measure ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

mi      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

mp      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

nal     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

ndr     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

ni      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

nmo     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

nv      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

ogv     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

oh      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

rbp     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

rdr     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

ri      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

rmo     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

rni     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

rnp     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

rp      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

rsnp    <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

rv      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

rvpa    <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

rwmi    <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

sal     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

saps    <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

sasv    <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

sbp     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

sc      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

select  <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

si      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

sl      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

sleep   <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

sort    <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

sp      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

spps    <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

spsv    <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

start   <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

sv      <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

swmi    <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

tee     <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

where   <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n

write   <\/span>ReadOnly, AllScope<\/span><\/span><\/span><\/p>\n<\/blockquote>\n

Now, compare the results of this list with the output for the following listing of aliases that are not marked Read-only. <\/p>\n

\n

PS C:\\> gal | ? { $_.options -notmatch ‘readonly’ } | ft name, options -a<\/span><\/span><\/span><\/p>\n

 <\/span><\/span><\/span><\/p>\n

Name     <\/span>Options<\/span><\/span><\/span><\/p>\n

—-     <\/span>——-<\/span><\/span><\/span><\/p>\n

cat     <\/span>AllScope<\/span><\/span><\/span><\/p>\n

cd      <\/span>AllScope<\/span><\/span><\/span><\/p>\n

chdir   <\/span>AllScope<\/span><\/span><\/span><\/p>\n

clear   <\/span>AllScope<\/span><\/span><\/span><\/p>\n

cls     <\/span>AllScope<\/span><\/span><\/span><\/p>\n

copy    <\/span>AllScope<\/span><\/span><\/span><\/p>\n

cp      <\/span>AllScope<\/span><\/span><\/span><\/p>\n

del     <\/span>AllScope<\/span><\/span><\/span><\/p>\n

dir     <\/span>AllScope<\/span><\/span><\/span><\/p>\n

echo    <\/span>AllScope<\/span><\/span><\/span><\/p>\n

epsn    <\/span>AllScope<\/span><\/span><\/span><\/p>\n

erase   <\/span>AllScope<\/span><\/span><\/span><\/p>\n

etsn    <\/span>AllScope<\/span><\/span><\/span><\/p>\n

exsn    <\/span>AllScope<\/span><\/span><\/span><\/p>\n

gjb     <\/span>AllScope<\/span><\/span><\/span><\/p>\n

gsn     <\/span>AllScope<\/span><\/span><\/span><\/p>\n

h       <\/span>AllScope<\/span><\/span><\/span><\/p>\n

history AllScope<\/span><\/span><\/span><\/p>\n

i           <\/span>None<\/span><\/span><\/span><\/p>\n

icm     <\/span>AllScope<\/span><\/span><\/span><\/p>\n

ipsn    <\/span>AllScope<\/span><\/span><\/span><\/p>\n

kill    <\/span>AllScope<\/span><\/span><\/span><\/p>\n

lp      <\/span>AllScope<\/span><\/span><\/span><\/p>\n

ls      <\/span>AllScope<\/span><\/span><\/span><\/p>\n

man     <\/span>AllScope<\/span><\/span><\/span><\/p>\n

md      <\/span>AllScope<\/span><\/span><\/span><\/p>\n

mount   <\/span>AllScope<\/span><\/span><\/span><\/p>\n

move    <\/span>AllScope<\/span><\/span><\/span><\/p>\n

mv      <\/span>AllScope<\/span><\/span><\/span><\/p>\n

nsn     <\/span>AllScope<\/span><\/span><\/span><\/p>\n

popd    <\/span>AllScope<\/span><\/span><\/span><\/p>\n

ps      <\/span>AllScope<\/span><\/span><\/span><\/p>\n

pushd   <\/span>AllScope<\/span><\/span><\/span><\/p>\n

pwd     <\/span>AllScope<\/span><\/span><\/span><\/p>\n

r       <\/span>AllScope<\/span><\/span><\/span><\/p>\n

rcjb    <\/span>AllScope<\/span><\/span><\/span><\/p>\n

rd      <\/span>AllScope<\/span><\/span><\/span><\/p>\n

ren     <\/span>AllScope<\/span><\/span><\/span><\/p>\n

rjb     <\/span>AllScope<\/span><\/span><\/span><\/p>\n

rm      <\/span>AllScope<\/span><\/span><\/span><\/p>\n

rmdir   <\/span>AllScope<\/span><\/span><\/span><\/p>\n

rsn     <\/span>AllScope<\/span><\/span><\/span><\/p>\n

sajb    <\/span>AllScope<\/span><\/span><\/span><\/p>\n

set     <\/span>AllScope<\/span><\/span><\/span><\/p>\n

spjb    <\/span>AllScope<\/span><\/span><\/span><\/p>\n

type    <\/span>AllScope<\/span><\/span><\/span><\/p>\n

wjb     <\/span>AllScope<\/span><\/span><\/span><\/span><\/p>\n<\/blockquote>\n

The r<\/b> <\/i>alias is mine; it is short for Invoke-History<\/b>. But that is beyond the point. If you look at the results of the previous list, you see things like md<\/b>, rd<\/b>, rmdir<\/b>, and ls<\/b>, cat<\/b>, and man<\/b>. I call these aliases compatibility aliases because they make Windows PowerShell compatible with UNIX or Windows shell environments. Therefore, a Windows administrator probably knows how to use dir<\/b> to produce a list of files from the file system. It is easier to use the dir<\/b> <\/i>command, especially early on, to tell that Windows admin you must learn the gci<\/b> <\/i>or Get-ChildItem<\/b>. <\/p>\n

The first set of aliases (the ones marked Read-only) are not compatible with either Windows or UNIX. The commands only have meaning within Windows PowerShell itself. Many times, they are the first initials of stressed syllables. This is seen in gci<\/b> for Get-ChildItem<\/b> or ebp<\/b> for Enable-BreakPoint<\/b>, gps<\/b> for Get-ProceSs<\/b>, or even gsv<\/b> for Get-SerVice<\/b>. Nevertheless, this is not always the case. For example, gmo<\/b> for Get-Module<\/b> does not seem to follow the pattern. <\/p>\n

Therefore, if you do not like gmo<\/b> for Get-Module<\/b>, you can remove it. But how does one remove an alias? The logical first step is to use the Get-Command<\/b> cmdlet to see if there is a cmdlet named Remove-Alias<\/b>. As shown in the following output, such a command does not exist.<\/p>\n

\n

PS C:\\> Get-Command -Noun alias<\/span><\/span><\/span><\/p>\n

 <\/span><\/span><\/span><\/p>\n

CommandType     <\/span>Name                                      <\/span>Definition<\/span><\/span><\/span><\/p>\n

———–     <\/span>—-                                      <\/span>———-<\/span><\/span><\/span><\/p>\n

Cmdlet          <\/span>Export-Alias                              <\/span>Export-Alias [-Path] <String> [[-Name]…<\/span><\/span><\/span><\/p>\n

Cmdlet          <\/span>Get-Alias             <\/span>                    <\/span>Get-Alias [[-Name] <String[]>] [-Exclu…<\/span><\/span><\/span><\/p>\n

Cmdlet          <\/span>Import-Alias                              <\/span>Import-Alias [-Path] <String> [-Scope …<\/span><\/span><\/span><\/p>\n

Cmdlet          <\/span>New-Alias                                 <\/span>New-Alias [-Name] <String> [-Value] <S…<\/span><\/span><\/span><\/p>\n

Cmdlet          <\/span>Set-Alias                                 <\/span>Set-Alias [-Name] <String> [-Value] <S…<\/span><\/span><\/span><\/p>\n<\/blockquote>\n

Remember the *-item<\/b> cmdlets? The reason they are all named something about an item is that an item can be anything. It all depends on the provider. In Windows PowerShell, there are many different providers, each of which makes use of the *-item<\/b> cmdlets. As shown here, on my laptop, there are eight different providers. A quick review of the list will show to even the most casual observer that there is a provider named Alias, and that the Alias provider exposes a drive named Alias. <\/p>\n

\n

PS C:\\> Get-PSProvider<\/span><\/span><\/span><\/p>\n

 <\/span><\/span><\/span><\/p>\n

Name                 <\/span>Capabilities                            <\/span>Drives<\/span><\/span><\/span><\/p>\n

—-                 <\/span>————                            <\/span>——<\/span><\/span><\/span><\/p>\n

WSMan           <\/span>     <\/span>Credentials                             <\/span>{WSMan}<\/span><\/span><\/span><\/p>\n

Alias                <\/span>ShouldProcess                           <\/span>{Alias}<\/span><\/span><\/span><\/p>\n

Environment          <\/span>ShouldProcess                           <\/span>{Env}<\/span><\/span><\/span><\/p>\n

FileSystem           <\/span>Filter, ShouldProcess                   <\/span>{C, Bin, D, E}<\/span><\/span><\/span><\/p>\n

Function             <\/span>ShouldProcess                           <\/span>{Function}<\/span><\/span><\/span><\/p>\n

Registry             <\/span>ShouldProcess, Transactions             <\/span>{HKLM, HKCU, HKCR}<\/span><\/span><\/span><\/p>\n

Variable             <\/span>ShouldProcess                           <\/span>{Variable}<\/span><\/span><\/span><\/p>\n

Certificate          <\/span>ShouldProcess                           <\/span>{cert}<\/span><\/span><\/span><\/p>\n<\/blockquote>\n

A review of the *-item<\/b> cmdlets shows that there is a Remove-Item<\/b> cmdlet. This is shown here. <\/p>\n

\n

PS C:\\> Get-Command -Noun item<\/span><\/span><\/span><\/p>\n

 <\/span><\/span><\/span><\/p>\n

CommandType     <\/span>Name                                      <\/span>Definition<\/span><\/span><\/span><\/p>\n

———–    <\/span> <\/span>—-                                      <\/span>———-<\/span><\/span><\/span><\/p>\n

Cmdlet          <\/span>Clear-Item                                <\/span>Clear-Item [-Path] <String[]> [-Force]…<\/span><\/span><\/span><\/p>\n

Cmdlet          <\/span>Copy-Item                                 <\/span>Copy-Item [-Path] <String[]> [[-Destin…<\/span><\/span><\/span><\/p>\n

Cmdlet          <\/span>Get-Item                                  <\/span>Get-Item [-Path] <String[]> [-Filter <…<\/span><\/span><\/span><\/p>\n

Cmdlet          <\/span>Invoke-Item                               <\/span>Invoke-Item [-Path] <String[]> [-Filte…<\/span><\/span><\/span><\/p>\n

Cmdlet          <\/span>Move-Item                                 <\/span>Move-Item [-Path] <String[]> [[-Destin…<\/span><\/span><\/span><\/p>\n

Cmdlet          <\/span>New-Item                                  <\/span>New-Item [-Path] <String[]> [-ItemType…<\/span><\/span><\/span><\/p>\n

Cmdlet          <\/span>Remove-Item                               <\/span>Remove-Item [-Path] <String[]> [-Filte…<\/span><\/span><\/span><\/p>\n

Cmdlet        <\/span>  <\/span>Rename-Item                               <\/span>Rename-Item [-Path] <String> [-NewName…<\/span><\/span><\/span><\/p>\n

Cmdlet          <\/span>Set-Item                                  <\/span>Set-Item [-Path] <String[]> [[-Value] …<\/span><\/span><\/span><\/p>\n<\/blockquote>\n

OK, so it should be a simple matter to use the alias drive and remove an alias. Let’s try it. <\/p>\n

\n

PS C:\\> Get-Alias gmo<\/span><\/span><\/span><\/p>\n

 <\/span><\/span><\/span><\/p>\n

CommandType     <\/span>Name                                      <\/span>Definition<\/span><\/span><\/span><\/p>\n

———–     <\/span>—-                                      <\/span>———-<\/span><\/span><\/span><\/p>\n

Alias           <\/span>gmo                                       <\/span>Get-Module<\/span><\/span><\/span><\/p>\n

 <\/span><\/span><\/span><\/p>\n

PS C:\\> Remove-Item alias:gmo<\/span><\/span><\/span><\/p>\n

Remove-Item : Alias was not removed because alias gmo is constant or read-only.<\/span><\/span><\/span><\/p>\n

At line:1 char:12<\/span><\/span><\/span><\/p>\n

+ Remove-Item <<<<  <\/span>alias:gmo<\/span><\/span><\/span><\/p>\n

    <\/span><\/span>+ CategoryInfo          <\/span>: WriteError: (gmo:String) [Remove-Item], SessionStateUnauthorizedAcce<\/span><\/span><\/span><\/span><\/p>\n

   <\/span><\/span>ssException<\/span><\/span><\/span><\/span><\/p>\n

    <\/span><\/span>+ FullyQualifiedErrorId : AliasNotRemovable,Microsoft.PowerShell.Commands.RemoveItemCommand<\/span><\/span><\/span><\/span><\/p>\n<\/blockquote>\n

Well, that did not work. It says the alias might be constant or Read-only. It does not specify a remedy (interestingly enough). But I know from working with the variable drive that I can remove a Read-only variable by using the –Force<\/b> switch. Let’s try it here. <\/p>\n

\n

PS C:\\> Remove-Item alias:gmo –Force<\/span><\/span><\/span><\/p>\n<\/blockquote>\n

The command did not generate an error; however, I am not convinced that it actually worked because nothing was returned. The way to check it is to use the Get-Alias<\/b> cmdlet to retrieve it. I do this, and an error is generated that states the alias gmo<\/b> does not exist. This is shown here. <\/p>\n

\n

PS C:\\> Get-Alias gmo<\/span><\/span><\/span><\/p>\n

Get-Alias : This command cannot find a matching alias because alias with name ‘gmo’ do not exist.<\/span><\/span><\/span><\/p>\n

At line:1 char:10<\/span><\/span><\/span><\/p>\n

+ Get-Alias <<<<  <\/span>gmo<\/span><\/span><\/span><\/p>\n

    <\/span><\/span>+ CategoryInfo          <\/span>: ObjectNotFound: (gmo:String) [Get-Alias], ItemNotFoundException<\/span><\/span><\/span><\/span><\/p>\n

    <\/span><\/span>+ FullyQualifiedErrorId : ItemNotFoundException,Microsoft.PowerShell.Commands.GetAliasCommand<\/span><\/span><\/span><\/span><\/p>\n<\/blockquote>\n

What if I later suffer from “deletion regret?” Am I stuck? Do I have to reinstall Windows 7 just to get that silly alias back? <\/p>\n

The answer, of course, is, “No, I do not have to reinstall Windows 7 to get the gmo<\/b> alias back.” All I have to do is to close Windows PowerShell, and then open it. When I do that, I use the Get-Alias<\/b> cmdlet again to see if it is there. As shown here, it is.<\/p>\n

\n

PS C:\\> Get-Alias gmo<\/span><\/span><\/span><\/p>\n

 <\/span><\/span><\/span><\/p>\n

CommandType     <\/span>Name                                      <\/span>Definition<\/span><\/span><\/span><\/p>\n

———–     <\/span>—-                                      <\/span>———-<\/span><\/span><\/span><\/p>\n

Alias           <\/span>gmo                                       <\/span>Get-Module<\/span><\/span><\/span><\/p>\n<\/blockquote>\n

Now, if the alias returns every time I start Windows PowerShell, then what is the harm? Maybe I really hate the gmo<\/b> alias, and I never want to look at it again. All I need to do is to add my previous command to my Windows PowerShell profile, and the alias will never again appear, unless I choose to use it for something. <\/p>\n

The real danger of using an alias in a script<\/h4>\n

This then, is the danger of using aliases in a script. I will give a quick story, and end this. I was teaching a Windows PowerShell class in Copenhagen, Denmark a few years ago, and one of my students spent all of his free time (and long into the night) working on his profile. He spent hours and hours making his Windows PowerShell environment look like a command environment he had on a different system. He created various variables, customized his prompt, changed the background color, modified the Windows PowerShell window title and everything else he could think of to do. One of the things he did was remove the alias ls<\/b> (a compatibility alias for Get-ChildItem<\/b>). After he did that, he redefined the alias to Set-Location<\/b>. <\/p>\n

The interesting thing is that both commands accept a string as the default argument…and that string is a path. This means that a script that uses ls<\/b> to get a directory listing would instead change the working location of the script to that directory. Depending on what the following commands were, the results could be disastrous, and no error would be generated because the signatures are the same. <\/p>\n

For my student, this decision made sense—after all, aliases are a convenience factor, and because he never intended to use ls<\/b> for Get-ChildItem<\/b>, there is no harm. The big problem, of course, would be if he ran a script from someone else who used that alias for Get-ChildItem<\/b>. <\/p>\n

You might not always control where and how a script will be run. You cannot be guaranteed that an alias will exist in an environment. And if that alias does exist, you cannot be guaranteed that it means the same thing everywhere. Of, course, you can always check to see if an alias exists, and if it means what you expect it to mean. An example of this is shown here.<\/p>\n

\n

if ((Get-Alias ls).definition -match ‘Get-Childitem’) { ls }<\/span><\/span><\/span><\/p>\n<\/blockquote>\n

But using code such as this really defeats the purpose of using an alias. In the end, it is a best practice to avoid using aliases in enterprise production-level scripts. The same is true when it comes to using positional arguments or partial parameter names. <\/p>\n

I invite you to follow me on Twitter<\/a> and Facebook<\/a>. If you have any questions, send email to me at scripter@microsoft.com<\/a>, or post your questions on the Official Scripting Guys Forum<\/a>. See you tomorrow. Until then, peace.<\/p>\n

Ed Wilson, Microsoft Scripting Guy<\/b><\/p>\n","protected":false},"excerpt":{"rendered":"

Summary: Microsoft Scripting Guy, Ed Wilson, discusses the use of aliases in Windows PowerShell scripts. He covers the pros and cons in this blog. Weekend Scripter Microsoft Scripting Guy, Ed Wilson, is here. “You can have my aliases when you pry my cold dead fingers from my keyboard,” was not one of the emails I […]<\/p>\n","protected":false},"author":595,"featured_media":87096,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[69,51,3,4,61,45,77],"class_list":["post-14071","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-functions","tag-getting-started","tag-scripting-guy","tag-scripting-techniques","tag-weekend-scripter","tag-windows-powershell","tag-writing"],"acf":[],"blog_post_summary":"

Summary: Microsoft Scripting Guy, Ed Wilson, discusses the use of aliases in Windows PowerShell scripts. He covers the pros and cons in this blog. Weekend Scripter Microsoft Scripting Guy, Ed Wilson, is here. “You can have my aliases when you pry my cold dead fingers from my keyboard,” was not one of the emails I […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/14071","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/users\/595"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/comments?post=14071"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/14071\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media\/87096"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media?parent=14071"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=14071"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=14071"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}