{"id":9421,"date":"2012-05-15T00:01:00","date_gmt":"2012-05-15T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2012\/05\/15\/find-powershell-commands-by-using-the-get-command-cmdlet\/"},"modified":"2012-05-15T00:01:00","modified_gmt":"2012-05-15T00:01:00","slug":"find-powershell-commands-by-using-the-get-command-cmdlet","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/find-powershell-commands-by-using-the-get-command-cmdlet\/","title":{"rendered":"Find PowerShell Commands by Using the Get-Command Cmdlet"},"content":{"rendered":"

Summary<\/b>: Microsoft Scripting Guy, Ed Wilson, shows how to use the Get-Command<\/b> cmdlet in Windows PowerShell to find various commands.<\/p>\n

\"Hey, Hey, Scripting Guy! It all seems so easy for you. You want to find something by using Windows PowerShell and ba-da-bing, it is there. But for those of us who have not been using Windows PowerShell since before it was ever released, what is the secret? I mean using Windows PowerShell does not seem hard—but there is so much of it. Every day, it seems that you perform this act, and it is like Windows PowerShell theatre. Of course, it works, but how did you find it in the first place? I hope I am making myself clear…I do not even know where to start.<\/p>\n

—RS<\/p>\n

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

Microsoft Scripting Guy, Ed Wilson, is here. Today the day seems late, or early, depending on one’s perspective. It is nearly noon, and the sun does not appear to have awakened. The skies are all gray, and a thin drizzle of rainfall is providing a nice drink of cool water for our parched trees and plants. The Scripting Wife<\/a> and I took our tea on the lanai this morning as we discussed Microsoft TechEd 2012 in Orlando<\/a>.<\/p>\n

“You need to get everything planned,” she said. “TechEd will be here sooner than you think.”<\/p>\n

“Actually, I think TechEd will arrive exactly on Monday, June 11. We have to have the Scripting Guys booth set up by noon on June 10. That is also when we will see Daniel Cruz<\/a>, who is helping out in the booth. We may also get to see Rohn Edwards and Lido Paglia, the 2012 Scripting Games winners<\/a>,” I said.<\/p>\n

“It is going to be so much fun,” she replied, “And the TechEd party is going to be held at Universal Islands of Adventure theme park. How cool is that?”<\/p>\n

“That is true, but I am really just looking forward to meeting people and to making new friends. For me, TechEd is all about the networking opportunities.”<\/p>\n

“So, speaking of networking,” she began, “How are you doing about creating the Scripting Guys guest schedule?”<\/p>\n

“Well, so far, I have Mark Minasi, Don Jones, Jeffery Hicks, Jeffrey Snover, and a few others scheduled to make guest appearances at the Scripting Guys booth. I also have a confirmation from O’Reilly press for my autograph session at their booth.”<\/p>\n

“So are you going to let me in on the secret? Or are you going to keep it all to yourself?” she asked.<\/p>\n

“Well, for now, I will keep it to myself,” I said with a smile.<\/p>\n

“Well, then for now, I am heading out with my friends,” she said with a smile, “I think we are going to check out that new store that opened up near the interstate.”<\/p>\n

And with no further ado, she was gone.<\/p>\n

So, RS, I decided to head upstairs to check out the email sent to scripter@microsoft.com<\/a>, and I ran across your email.<\/p>\n

Note   <\/b>Tomorrow night, May 16, 2012 at 9:30 PM Eastern Standard Time (-5 GMT), the two winners of the 2012 Scripting Games<\/a> (Lido Paglia and Rohn Edwards), Jeffrey Snover, and myself all appear with Jonathan Walz and Hal Rottenberg on the PowerScripting Podcast<\/a>. This event is recorded live, and there is a chat room set up so you can talk to your fellow listeners, in addition to asking questions of the guests. It will be a lot of fun, and you should not miss it if at all possible.<\/p>\n

The easy way to find Windows PowerShell cmdlets<\/h2>\n

The first thing to keep in mind is that in Windows PowerShell, not everything is a cmdlet. There are language statements, functions, aliases, various objects (from the .NET Framework or COM), and even other executables—all of which are utilizable from within Windows PowerShell. In Windows 8 Consumer Preview, this means you have around 1000 commands from which to choose. In Windows 7, the situation is not quite so overwhelming, but still you need to know how to find what you want.<\/p>\n

In Windows 7, much of the power of Windows PowerShell comes from WMI. (This is actually true in Windows 8 Consumer Preview also, but the WMI classes are exposed more directly.) For information about searching and working with WMI, see this collection of Hey, Scripting Guy! Blogs<\/a>.<\/p>\n

Note   <\/b> In yesterday’s blog, Discover the Easy Way to Begin Learning Windows PowerShell<\/a>, <\/i>I talked about learning the Windows PowerShell Verb-Noun naming pattern as a way to develop an understanding of Windows PowerShell coverage. This technique will also aid in finding Windows PowerShell cmdlets.<\/p>\n

Two cmdlets are essential for discovering Windows PowerShell commands. The first is the Get-Command<\/b> cmdlet, and the second is the Get-Help<\/b> cmdlet. At first glance, the Get-Command<\/b> cmdlet might not appear to be all that useful. For example, you provide it with the name of a cmdlet, and basically what returns is the name of the cmdlet. This command is shown here.<\/p>\n

Get-Command Get-Process<\/p>\n

The command and the output associated with the command illustrate the problem. <\/i>The default output does not appear to display much more information than you knew when you typed in the command. You figured it was a cmdlet, you knew the name of Get-Process<\/b>, and the definition does not add much additional information.<\/p>\n

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

But, remember, everything in Windows PowerShell is an object. In fact, the Get-Command<\/b> cmdlet returns a CmdletInfo<\/b> object. This is shown here.<\/p>\n

PS C:\\> Get-Command Get-Process | gm<\/p>\n

 <\/p>\n

   TypeName: System.Management.Automation.CmdletInfo<\/p>\n

 <\/p>\n

Name                MemberType     Definition<\/p>\n

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

Equals              Method         bool Equals(System.Object obj)<\/p>\n

GetHashCode         Method         int GetHashCode()<\/p>\n

GetType             Method         type GetType()<\/p>\n

ToString            Method         string ToString()<\/p>\n

CommandType         Property       System.Management.Automation.CommandTypes Comm…<\/p>\n

DefaultParameterSet Property       System.String DefaultParameterSet {get;}<\/p>\n

Definition          Property       System.String Definition {get;}<\/p>\n

HelpFile            Property       System.String HelpFile {get;}<\/p>\n

ImplementingType    Property       System.Type ImplementingType {get;}<\/p>\n

Module              Property       System.Management.Automation.PSModuleInfo Modu…<\/p>\n

ModuleName          Property       System.String ModuleName {get;}<\/p>\n

Name                Property       System.String Name {get;}<\/p>\n

Noun                Property       System.String Noun {get;}<\/p>\n

OutputType          Property       System.Collections.ObjectModel.ReadOnlyCollect…<\/p>\n

Parameters          Property       System.Collections.Generic.Dictionary`2[[Syste…<\/p>\n

ParameterSets       Property       System.Collections.ObjectModel.ReadOnlyCollect…<\/p>\n

PSSnapIn            Property       System.Management.Automation.PSSnapInInfo PSSn…<\/p>\n

Verb                Property       System.String Verb {get;}<\/p>\n

Visibility          Property       System.Management.Automation.SessionStateEntry…<\/p>\n

DLL                 ScriptProperty System.Object DLL {get=$this.ImplementingType….<\/p>\n

HelpUri             ScriptProperty System.Object HelpUri {get=try…<\/p>\n

Based on the members of the CmdletInfo<\/b> object, there appears to be a lot of information available about the cmdlet. The easiest way to view this information is to pipe the output from the Get-Command<\/b> cmdlet to the Format-List<\/b> cmdlet and to use a wild card character to choose all available properties. The command is shown here (fl<\/b> is an alias for the Format-List<\/b> cmdlet).<\/p>\n

Get-Command Get-Process | fl *<\/p>\n

The command, and the output associated with the command are shown in the image that follows.<\/p>\n

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

In yesterday’s Hey, Scripting Guy! Blog, I talked about working with Windows PowerShell verbs <\/i>as a way of understanding available commands. When you know and understand the various verbs, using the Get-Command<\/b> cmdlet becomes much more valuable. For example, when you are looking for information about various items, you know you will more than likely use the get<\/b> <\/i>verb. Therefore, use the Get-Command<\/b> cmdlet to retrieve only cmdlets that use the get<\/b> <\/i>verb. This command is shown here.<\/p>\n

Get-Command –verb get<\/p>\n

If you seek cmdlets that will assign a new value to something, you more than likely are looking for a cmdlet that uses the set<\/b> <\/i>verb. The following command retrieves these types of cmdlets.<\/p>\n

Get-Command –verb set<\/p>\n

Use nouns <\/i>for cmdlets<\/h2>\n

One of the things that tends to confuse beginners is the difference between the name <\/i>and the noun <\/i>parameters. The Get-Command<\/b> cmdlet has multiple parameter sets, and when you use the verb <\/i>or the noun <\/i>parameter, the Get-Command<\/b> cmdlet only returns cmdlets. If you use the name <\/i>parameter, Get-Command<\/b> finds cmdlets, executables, functions, aliases, and other types of commands.<\/p>\n

A good way to find commands is to use wild cards. For example, the following command returns any command containing the letters adapter <\/i>within the name of the command. The output reveals that one command meets this filter.<\/p>\n

PS C:\\> gcm -Name *adapter*<\/p>\n

CommandType     Name                               Definition<\/p>\n

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

Application     AdapterTroubleshooter.exe          C:\\Windows\\system32\\AdapterTro…<\/p>\n

\n

Note  <\/b> Because the Get-Command<\/b> cmdlet returns more than Windows PowerShell cmdlets, I often use it to help me locate various Windows executables. Because the Windows PowerShell console is generally open on my computer, it is faster for me to use than to use Windows Search.<\/p>\n

In the following image, I first look for commands related to process. <\/i>The first results (obtained by using the name <\/i>parameter) contain a number of applications, in addition to several Windows PowerShell cmdlets. When I limit the results to only cmdlets that have a noun <\/i>related to process <\/i>the results are more directed.<\/p>\n

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

RS, that is all there is to using the Get-Command<\/b> cmdlet to search for cmdlets. Join me tomorrow when I will talk about additional ways to use Get-Command<\/b>. It will be a very cool blog (and one not only for beginners).<\/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, shows how to use the Get-Command cmdlet in Windows PowerShell to find various commands.  Hey, Scripting Guy! It all seems so easy for you. You want to find something by using Windows PowerShell and ba-da-bing, it is there. But for those of us who have not been using Windows […]<\/p>\n","protected":false},"author":596,"featured_media":87096,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[51,3,4,45],"class_list":["post-9421","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-getting-started","tag-scripting-guy","tag-scripting-techniques","tag-windows-powershell"],"acf":[],"blog_post_summary":"

Summary: Microsoft Scripting Guy, Ed Wilson, shows how to use the Get-Command cmdlet in Windows PowerShell to find various commands.  Hey, Scripting Guy! It all seems so easy for you. You want to find something by using Windows PowerShell and ba-da-bing, it is there. But for those of us who have not been using Windows […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/9421","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\/596"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/comments?post=9421"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/9421\/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=9421"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=9421"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=9421"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}