{"id":52063,"date":"2009-11-09T00:01:00","date_gmt":"2009-11-09T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2009\/11\/09\/hey-scripting-guy-tell-me-about-aliases-in-windows-powershell\/"},"modified":"2009-11-09T00:01:00","modified_gmt":"2009-11-09T00:01:00","slug":"hey-scripting-guy-tell-me-about-aliases-in-windows-powershell","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/hey-scripting-guy-tell-me-about-aliases-in-windows-powershell\/","title":{"rendered":"Hey, Scripting Guy! Tell Me About Aliases in Windows PowerShell"},"content":{"rendered":"

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

 <\/p>\n

\"Hey,<\/p>\n

Hey, Scripting Guy! I have been playing around with Windows PowerShell 2.0 in Windows 7 and I think that I like it. However, it seems to require an awful lot of typing. The double command names, such as Get-Process<\/b>, are somewhat helpful for remembering things, but it is quite a bit of typing. Yes, it is shorter than writing a VBScript to return the same information, but did you have to make everything so long? And by the way, while I am whining, I hate typing the hyphen. It is too hard to find on my keyboard. I do not expect you to change Windows PowerShell just for me, but surely there are others out there who feel the same way I do. If Windows PowerShell is supposed to be the all-new management tool for administrators, you could have made it easier to use. <\/p>\n

— RR<\/p>\n

\"Hey,Hello, RR. <\/p>\n

Microsoft Scripting Guy Ed Wilson here. Well I just got off a two-hour Live Meeting with a customer. I was talking about some of the new remoting features in Windows PowerShell 2.0. It was an awesome talk, if I do say so myself. I love talking to customers, and I love working with Windows PowerShell 2.0. On those occasions when I combine those two passions, it is a great day.<\/p>\n

RR, it seems that I need to introduce you to the concept of aliases. Consider a command such as Measure-Object<\/b> that is used to count information and provide statistical information such as the minimum and maximum values of an object. Measure-Object<\/b> can be a bit cumbersome to type from a command line, and given the relative frequency of its use, it becomes a good candidate for aliasing. <\/p>\n

Note: Portions of today’s Hey, Scripting Guy! post are excerpted from the Microsoft Press book, Windows PowerShell 2.0 Best Practices<\/i> by Ed Wilson. The book is available for pre-order<\/a>. <\/p>\n

Verifying the existence of an alias<\/font><\/strong><\/p>\n

Before creating a new alias, it is a best practice to see if there is a suitable alias already created for the cmdlet in question. By default, Windows PowerShell ships with more than 130 predefined aliases for its 271 cmdlets. When you consider that several of the cmdlets have more than one alias defined, you can see there is great opportunity for the creation of additional aliases. The ListCmdletsWithMoreThanOneAlias.ps1 script lists all cmdlets that have more than one alias defined. This script is seen here. <\/p>\n

ListCmdletsWithMoreThanOneAlias.ps1
<\/strong>
Get-Alias |
Group-Object -Property definition |
Sort-Object -Property count -Descending |
Where-Object { $_.count -gt 2 }<\/p>\n

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

 <\/p>\n

When the ListCmdletsWithMoreThanOneAlias.ps1 script runs, the following appears:<\/p>\n

Count Name                      <\/span>Group
—– —-                      <\/span>—–
    <\/span>6 Remove-Item               <\/span>{del, erase, rd, ri…}
    <\/span>3 Set-Location              <\/span>{cd, chdir, sl}
    <\/span>3 Get-History               <\/span>{ghy, h, history}
    <\/span>3 Get-ChildItem             <\/span>{dir, gci, ls}
    <\/span>3 Get-Content               <\/span>{cat, gc, type}
    <\/span>3 Move-Item                 <\/span>{mi, move, mv}
    <\/span>3 Copy-Item                 <\/span>{copy, cp, cpi}<\/p>\n

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

To see if an alias for the Measure-Object<\/b> cmdlet exists already, you can use the Get-Alias<\/b> cmdlet and the -definition<\/b> parameter as shown here: <\/p>\n

PS C:> Get-Alias -Definition Measure-Object<\/p>\n

CommandType     <\/span>Name                                      <\/span>Definition
———–     <\/span>—-                                      <\/span>———-
Alias           <\/span>measure                                   <\/span>Measure-Object<\/p>\n

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

If you like the alias measure<\/b>, you can use that alias. However, you may decide that the readability of the alias measure<\/b> is hampered by the fact, that it only saves two key strokes. Because of the implementation of the tab expansion feature, all you need to do is type measure-o<\/b> and press TAB. In general, when creating personal aliases, I prefer to sacrifice readability for ease of use. My very favorite aliases are one-letter and two-letter aliases. I use the one-letter aliases for commands I frequently use, because they are the most useful and most obscure. I use the two-letter aliases for most of my other alias needs. The two-letter combination can easily correspond to the verb noun naming convention. Therefore, mo<\/b> would be a logical alias for the Measure-Object<\/b> cmdlet. To ensure its availability, use the Get-Alias<\/b> cmdlet as shown here:<\/p>\n

PS C:> Get-Alias -Name mo<\/p>\n

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

How many two-letter aliases are there?<\/font><\/strong><\/p>\n

The two-letter alias namespace is rather large. How large? You have to take every letter in the range A-Z, and pair it with every other letter in the range of A-Z. If you are good with algebra then you immediately know there are 676 possible letter combinations (26 x 26). However, if your algebra is a bit rusty, you may wish to write a Windows PowerShell script to figure it out for you. The problem with such an approach is that we cannot use the range<\/b> operator to produce a range of letters. It works with numbers, so 1..10<\/b> automatically creates a range of numbers with the values 1 through 10, and can save you a lot of typing. However, because we have ASCII numeric representations of the letters A-Z, you can use this technique to create a range of letters. The ASCII value 97 is the “A” character, and the ASCII value 122 is “Z”. After we have the numeric range, we use the ForEach-Object<\/b> cmdlet and convert each letter to a character by using the [char]<\/b> type. We store the resulting array of letters in the $letters<\/b> variable. We then do two loops through the array and store the resulting letter combinations in the $lettercombination<\/b> variable, which is constrained as an array by using the [array]<\/b> type. The Measure-Object<\/b> cmdlet is used to count the number of possible letter combinations. The ListTwoLetterCombinations.ps1 script is shown here. <\/p>\n

ListTwoLetterCombinations.ps1<\/strong><\/p>\n


$letterCombinations = $null
$asciiNum = 97..122
$letters = $asciiNum | ForEach-Object { [char]$_ }
Foreach ($1letter in $letters)
{
 <\/span>Foreach ($2letter in $letters)
 <\/span>{
  <\/span>[array]$letterCombinations += “$1letter$2letter”
 <\/span>}
}
“There are ” + ($letterCombinations | Measure-Object).count + ” possible combinations”
“They are listed here: “
$letterCombinations<\/p>\n

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

To create a new alias, you can use either the New-Alias<\/b> cmdlet or the Set-Alias<\/b> cmdlet. You could also use the New-Item<\/b> cmdlet and target the Alias<\/b> drive. The problem with that technique is it does not support the Description<\/b> parameter, which allows you to specify additional information about the alias. The other problem with using the New-Item<\/b> cmdlet to create an alias is that it is more typing. So as a best practice, I always use either the New-Alias<\/b> or the Set-Alias<\/b> cmdlet. <\/p>\n

In choosing between the two cmdlets, which should you use when creating a new alias? Before we answer that, we should actually talk about what the cmdlets are intended to be used for. The New-Alias<\/b> cmdlet, obviously creates a new alias. The Set-Alias<\/b> cmdlet is used to modify an existing alias. If an alias does not exist, it will create the alias for you. Therefore, many people use the Set-Alias<\/b> cmdlet to both create and modify an alias. There is a danger in this approach, however, in that you can inadvertently modify a previously existing alias with no notification. If this is your desired behavior, that approach is fine. A better approach is to use the New-Alias<\/b> cmdlet when creating an alias. This allows you to specify the Description<\/b> parameter, and to receive notification if an alias that you are trying to create already exists. To assign a description to an alias when creating it, you use the Description<\/b> parameter as seen here:<\/p>\n

New-Alias -Name mo -Value Measure-Object -Description “MrEd Alias”<\/p>\n

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

In an enterprise-scripting environment, many companies like defining a corporate set of aliases—this provides for a consistent environment. A network administrator working on one machine can be assured that a particular alias is available. This also helps to ensure a predictable and consistent environment. By using the same value for the Description<\/b> parameter of the alias, it is easy to list all the corporate aliases. To do this, you would filter the list of aliases by the description. An example of this is seen here:<\/p>\n

PS C:> Get-Alias | Where-Object { $_.description -eq ‘mred alias’ }<\/p>\n

CommandType     <\/span>Name                             <\/span>         <\/span>Definition
———–     <\/span>—-                                      <\/span>———-
Alias           <\/span>mo                                        <\/span>Measure-Object<\/p>\n

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

When using the -eq<\/b> operator in the code block of the Where-Object<\/b> cmdlet, the filter is case insensitive. If you need a case sensitive operator, you would use -ceq<\/b>. The “c” is added to all the operators to form a case sensitive form of the operator—by default the operators are case insensitive. As shown here, when using the case sensitive operator, the filter does not return any aliases:<\/p>\n

PS C:> Get-Alias | Where-Object { $_.description -ceq ‘mred alias’ }
PS C:><\/p>\n

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

In addition to specifying the Description<\/b> parameter, many companies also like to use the Option<\/b> parameter to make the alias either read-only or constant. To make the alias read-only, you supply the readonly<\/b> keyword to the Option<\/b> parameter. This is shown here:<\/p>\n

New-Alias -Name mo -Value Measure-Object -Description “MrEd Alias” -Option readonly<\/p>\n

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

The advantage of making the alias read-only is that it offers protection against accidental modification or deletion. This is seen here:<\/p>\n

\"Image<\/p>\n


There is an additional advantage to making the alias read-only: It can be modified or deleted if needed. If you wish to modify the description, you use the Set-Alias<\/b> cmdlet to specify the name, value<\/b> the new description, and use the Force<\/b> parameter. This is seen here:<\/p>\n

Set-Alias -Name mo -value measure-object -Description “my alias” –Force<\/p>\n

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

If you need to delete a read-only cmdlet, you use the Remove-Item<\/b> cmdlet and specify the Force<\/b> parameter. This is seen here:<\/p>\n

Remove-Item Alias:mo -Force<\/p>\n

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

To create a constant alias, you use the constant<\/b> keyword with the option<\/b> parameter. This technique is shown here:<\/p>\n

New-Alias -Name mo -Value Measure-Object -Description “MrEd Alias” -Option constant<\/p>\n

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

As a best practice, you should not create constant aliases unless you are certain you do not need to either modify them or delete them. This is because a constant alias can be neither modified nor deleted—in effect, they really are constant. The error message is a bit misleading in that it says the alias is either read-only or constant, and it suggests attempting to use the Force<\/b> parameter. The reason this is misleading is the message is displayed even when the command was run with the Force<\/b> parameter. This error message is seen here:<\/p>\n

\"Image<\/p>\n

 <\/p>\n

Well, RR, this should get you started on using aliases in Windows PowerShell. Join us tomorrow as we continue examining ways to customize our Windows PowerShell environment. <\/p>\n

If you want to know exactly what we will be looking at tomorrow, follow us on Twitter<\/a> or Facebook<\/a>. If you have any questions, send e-mail to us at scripter@microsoft.com<\/font><\/a> or post them on the Official Scripting Guys Forum<\/a>. See you tomorrow. Until then, keep on scripting!<\/p>\n

 <\/p>\n

<\/p>\n

<<\/p>\n

p style=”MARGIN-LEFT: 0in”>Ed Wilson and Craig Liebendorfer, Scripting Guys<\/p>\n

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

<\/font><\/font><\/b><\/p>\n

 <\/p>\n","protected":false},"excerpt":{"rendered":"

  Hey, Scripting Guy! I have been playing around with Windows PowerShell 2.0 in Windows 7 and I think that I like it. However, it seems to require an awful lot of typing. The double command names, such as Get-Process, are somewhat helpful for remembering things, but it is quite a bit of typing. Yes, […]<\/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":[51,3,45],"class_list":["post-52063","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-getting-started","tag-scripting-guy","tag-windows-powershell"],"acf":[],"blog_post_summary":"

  Hey, Scripting Guy! I have been playing around with Windows PowerShell 2.0 in Windows 7 and I think that I like it. However, it seems to require an awful lot of typing. The double command names, such as Get-Process, are somewhat helpful for remembering things, but it is quite a bit of typing. Yes, […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/52063","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=52063"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/52063\/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=52063"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=52063"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=52063"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}