{"id":51933,"date":"2009-11-25T00:01:00","date_gmt":"2009-11-25T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2009\/11\/25\/hey-scripting-guy-whats-the-deal-with-the-dash-in-cmdlet-names\/"},"modified":"2009-11-25T00:01:00","modified_gmt":"2009-11-25T00:01:00","slug":"hey-scripting-guy-whats-the-deal-with-the-dash-in-cmdlet-names","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/hey-scripting-guy-whats-the-deal-with-the-dash-in-cmdlet-names\/","title":{"rendered":"Hey, Scripting Guy! What’s the Deal with the Dash in Cmdlet Names?"},"content":{"rendered":"

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

\"Hey,<\/p>\n

Hey, Scripting Guy! I enjoy using Windows PowerShell, but I do not like the two-word cmdlet names you created for everything. As a matter of fact, I hate<\/i> the two-word cmdlet names because the dash (-) symbol is hard to type. I guess I will eventually get used to it, but you have to realize that Windows PowerShell as a tool for network administrators is really hard to use. I studied computer architecture and networking protocols at university—not<\/i> typing. I don’t suppose you can do anything about it now, but I just thought I would let off some steam. For a tool that is advertised to make things easier, it sure is hard to use. <\/p>\n

— BW<\/p>\n

\"Hey,Hello BW, <\/p>\n

Microsoft Scripting Guy Ed Wilson here. It is dark as pitch. Not a star in the sky. Not a street light visible through the thick evening fog. I am trying to catch up on e-mail sent to the scripter@microsoft.com<\/font><\/a> e-mail alias and get ready for the approaching holiday season in the United States. Between now and the new year, Craig and I will only be working a few overlapping days, and we are not going to publish reruns through the holidays as has been done in the past. This means burning the midnight oil so to speak. I enjoy working in the evening. I am listening to Phil Collins<\/font><\/a> on my Zune HD<\/font><\/a>, and sipping a cup of blueberry tea. The sleeping Office Communicator icon in the notification area of my Window 7 Task Bar and dearth of meetings means I can be doubly productive, which is perfect because I need to write twice the number of Hey, Scripting Guy! posts during the next two weeks to meet my goal. <\/p>\n

Anyway, BW, you seem to be averse to typing the dash symbol. You are not the first person who has mentioned this to me. If you really want to fix the problem, you can do it with a single-line command as shown here: <\/p>\n

gcm -CommandType cmdlet | % { Set-Alias ( $_.name -replace “-“,””) $_.name }<\/p>\n

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

GCM<\/b> is the alias for the Windows PowerShell Get-Command<\/b> cmdlet. An alias allows you to create a shortcut name for a command. Do this for commands that are hard to type, too long to type, or too difficult to remember. By using aliases, you can completely customize the way that you interact with Windows PowerShell. To see a list of the available aliases, use the Get-Alias<\/b> cmdlet, which will list aliases that are created by Windows PowerShell as well as any aliases you may have created yourself. <\/p>\n

Truncated output from the Get-Alias<\/b> cmdlet is seen just below. You will notice that the first alias that is listed is the percent sign. It is an alias for the ForEach-Object<\/b> cmdlet and was used in the code we used to remove the dash from all the cmdlet names. The next alias, the question mark, is also a commonly used alias. The problem a number of people coming from a DOS\/VBScript background have with the question mark alias is that command-line utilities often used the question mark for help. Some of the new aliases we created can also be seen. AddComputer<\/b>, AddContent<\/b>, and others are the standard command names with the dash removed. These are shown here:<\/p>\n

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

CommandType     <\/span>Name                                                <\/span>Definition
———–     <\/span>—-                                                <\/span>———-
Alias           <\/span>%                                                   <\/span>ForEach-Object
Alias           <\/span>?                                                   <\/span>Where-Object
Alias           <\/span>ac   <\/span>                                               <\/span>Add-Content
Alias           <\/span>AddComputer                                         <\/span>Add-Computer
Alias           <\/span>AddContent                                          <\/span>Add-Content
Alias           <\/span>AddHistory          <\/span>                                <\/span>Add-History
Alias           <\/span>AddMember                                           <\/span>Add-Member
Alias           <\/span>AddPSSnapin                                         <\/span>Add-PSSnapin
Alias           <\/span>AddType                             <\/span>                <\/span>Add-Type
Alias           <\/span>asnp                                                <\/span>Add-PSSnapIn
Alias           <\/span>cat                                                 <\/span>Get-Content<\/p>\n

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

The problem with simply executing a command inside the Windows PowerShell console is that once you close and re-open Windows PowerShell console, the aliases are gone. They will need to be recreated each time that you open Windows PowerShell. This is shown by the output seen here:<\/p>\n

Windows PowerShell
Copyright (C) 2009 Microsoft Corporation. All rights reserved.<\/p>\n

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

CommandType     <\/span>Name                                                <\/span>Definition
———–     <\/span>—-                                                <\/span>———-
Alias           <\/span>%                        <\/span>                           <\/span>ForEach-Object
Alias           <\/span>?                                                   <\/span>Where-Object
Alias           <\/span>ac                                                  <\/span>Add-Content
Alias           <\/span>asnp                                 <\/span>               <\/span>Add-PSSnapIn
Alias           <\/span>cat                                                 <\/span>Get-Content
Alias           <\/span>cd                                                  <\/span>Set-Location
Alias           <\/span>chdir                                              <\/span> <\/span>Set-Location<\/p>\n

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

One thing you can do to make sure you always have the aliases you wish is to save your command history after you have run the command to create the aliases. You can save your command history to an XML file by using the following command:<\/p>\n

Get-History |
Export-Clixml -Path c:fsohistory.xml<\/p>\n

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

The saved XML file can be viewed in XML Notepad as seen in the following image. The thing to keep in mind about this technique is you want to make sure that you have a clean command history by closing the Windows PowerShell console and re-opening it:<\/p>\n

\"Image<\/p>\n


After you have your newly created history.xml file, you need only to import the file and execute each of the commands in your command history. You can do this by using the following command:<\/p>\n

Import-Clixml C:fsohistory.xml |
add-history -passthru |
foreach-object {invoke-history}<\/p>\n

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

The use of this command is seen here. Notice that when the history is invoked, the command is displayed on the command line. The Get-Alias<\/b> cmdlet is then used to list the last four alises, which are our newly created aliases. <\/p>\n

PS C:> Import-Clixml C:fsohistory.xml |
>> add-history -passthru |
>> foreach-object {invoke-history}
>>
gcm -CommandType cmdlet | % { Set-Alias ( $_.name -replace “-“,””) $_.name }
PS C:> Get-Alias | select -Last 4<\/p>\n

CommandType     <\/span>Name                                                <\/span>Definition
———–     <\/span>—-                         <\/span>                       <\/span>———-
Alias           <\/span>WriteOutput                                         <\/span>Write-Output
Alias           <\/span>WriteProgress                                       <\/span>Write-Progress
Alias           <\/span>WriteVerbose                              <\/span>          <\/span>Write-Verbose
Alias           <\/span>WriteWarning                                        <\/span>Write-Warning<\/p>\n


PS C:><\/p>\n

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

One use of the export\/import command history technique would be in a setting where you were not permitted to run scripts. Because the Windows PowerShell profile is a script, the profile script will not run if the command execution policy is set to Restricted<\/b>. <\/p>\n

The best place to manage aliases, of course, is to use the Windows PowerShell profile. Our Windows PowerShell profile from yesterday<\/a> has been updated with the “remove the dash” command and a couple of additional aliases. The Profile.ps1 script is seen here. <\/p>\n

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

# HSG_Profile_11_24_09.ps1
# HSG-11-24-09
# Ed Wilson, MSFT, 11\/18\/2009
# Version 1.0<\/p>\n

# *** Variables ***
New-Variable -Name ProfileFolder -Value (Split-Path $PROFILE -Parent) `
   <\/span>-Description MrEd_Variable
New-Variable -Name IseProfile `
   <\/span>-Value (Join-Path -Path (Split-Path $PROFILE -Parent) `
   <\/span>-ChildPath Microsoft.PowerShellISE_profile.ps1) `
   <\/span>-Description MrEd_Variable
New-Variable -Name MyComputers -Value Hyperv,Win7-PC -Description MrEd_Variable
New-Variable -name temp -value $([io.path]::gettemppath()) -Description MrEd_Variable
Set-Variable -Name MaximumHistoryCount -Value 128 -Description MrEd_Variable<\/p>\n

# *** Alias ***
Get-Command -CommandType cmdlet |
Foreach-Object {
 <\/span>Set-Alias -name ( $_.name -replace “-“,””) -value $_.name -description MrEd_Alias
} #end Get-Command
New-Alias -name gh -value Get-Help -description MrEd_Alias
New-Alias -name i -value Invoke-History -description MrEd_Alias<\/p>\n

# *** PS Drive ***<\/p>\n

# *** Function ***<\/font><\/p>\n

Before transferring the “remove the dashes” command to the Windows PowerShell profile, I modified it by removing the aliases from the command (I know, it seems a little strange to remove aliases from a command that creates aliases) because as a best practice, you do not want to use aliases or positional arguments in scripts. Though it is possible to add aliases, it is also possible to remove aliases—even aliases that are included by default. Suppose, for example, that the use of the question mark for the Where-Object<\/b> cmdlet really bugs you, and you would rather use it for the Get-Help <\/b>cmdlet. No problem. You just modify the value of the alias. This is seen here:<\/p>\n

PS C:> Set-Alias -Name ? -Value Get-Help -Force -Option allscope
PS C:><\/font><\/p>\n

Maybe you really do not like the %<\/b> alias at all. You can remove the alias by using the Remove-Item<\/b> cmdlet. This is seen here. <\/p>\n

PS C:> Remove-Item alias:% -Force
PS C:><\/font><\/p>\n

All this is to say that when using an alias, you never know if it is going to exist or not, unless you totally control the environment. As a best practice, do not<\/i> use aliases in a script.  <\/span><\/p>\n

Two aliases that I like to use are gh<\/b> for the Get-Help<\/b> cmdlet and i<\/b> for the Invoke-History<\/b> cmdlet. When creating new aliases, I like to populate the description parameter. This is seen here:<\/p>\n

New-Alias -name gh -value Get-Help -description MrEd_Alias
New-Alias -name i -value Invoke-History -description MrEd_Alias <\/font><\/p>\n

The advantage of populating the description<\/b> parameter for the alias is it makes it easy to retrieve my custom aliases. I can do this by using the Get-Alias<\/b> cmdlet to retrieve all the defined aliases, and pipe the results to the Where-Object<\/b> cmdlet. The command and the truncated results are shown 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>AddComputer                                         <\/span>Add-Computer
Alias           <\/span>AddContent                                          <\/span>Add-Content
Alias           <\/span>AddHistory                                          <\/span>Add-History<\/font><\/p>\n

You might be wondering: “We just added a bunch of new aliases. Will we run out of space?” The answer is: Yes, it is possible. The $maxAliasCount<\/b> variable is set to 4096, but you can change that value if you need to. It is unlikely that you will need to modify this value. We still have plenty of room as shown here:<\/p>\n

PS C:> $MaximumAliasCount
4096
PS C:> Get-Alias | Measure-Object<\/p>\n

Count    <\/span>: 374
Average  <\/span>:
Sum      <\/span>:
Maximum  <\/span>:
Minimum  <\/span>:
Property :<\/p>\n

PS C:><\/font><\/p>\n

Of course, BW, our Windows PowerShell profile is really beginning to take shape at this point. We will add to our profile tomorrow as Windows PowerShell Profile Week continues. <\/p>\n

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

<<\/p>\n

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

!–><\/p>\n

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

Hey, Scripting Guy! I enjoy using Windows PowerShell, but I do not like the two-word cmdlet names you created for everything. As a matter of fact, I hate the two-word cmdlet names because the dash (-) symbol is hard to type. I guess I will eventually get used to it, but you have to realize […]<\/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,144,3,4,45],"class_list":["post-51933","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-getting-started","tag-profiles","tag-scripting-guy","tag-scripting-techniques","tag-windows-powershell"],"acf":[],"blog_post_summary":"

Hey, Scripting Guy! I enjoy using Windows PowerShell, but I do not like the two-word cmdlet names you created for everything. As a matter of fact, I hate the two-word cmdlet names because the dash (-) symbol is hard to type. I guess I will eventually get used to it, but you have to realize […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/51933","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=51933"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/51933\/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=51933"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=51933"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=51933"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}