So when doing shell things in macOS, (or Linux for that matter), you use things like “which” and “locate” a lot. They’re handy. Well, PowerShell, unsurprisingly has its own version, Get-Command, (Full syntax and examples at the Get-Command documentation page.)
There’s a lot there, but I wanted to talk about just two cases, getting a single command, and getting a list of similar commands. So if you just run Get-Command on a single command, i.e.
Get-Command pwsh, you get:
So this looks nice, but it’s functional. Let’s redo that command, but assign it to a variable:
$thePwshCommand = Get-Command pwsh
If we just run the variable name,
$thePwshCommand, you see the same thing as you would for
Get-Command pwsh. So like any generic string, but with some nicer display formatting right? Well, no. As it turns out, the results of Get-Command are not just a string as shown by
So as we see, it’s not a string, but rather something called CommandInfo. What does this mean? Well, let’s say you don’t care about the type of executable a command is, or the version, you just want the path. No string parsing needed, just use
Since CommandInfo is a kind of object, you have some fun options for using what it returns without having to dink around with sed, grep, or what have you. The language and runtime take care of it for you.
But wait, there’s more. Now, as we can see, I’m running a preview version of PowerShell. Which means there’s a chance that there’s other versions of pwsh on my system. (By default, Get-Command returns the first hit it finds.) So how do we get all the versions of pwsh? Wildcards
so as we can see, there’s a few things. But what happens if we use a var for that? Well, it’s kind of neat…first the command,
$allThingsPwsh = Get-Command pws*. If we just display the var, we get about what we expect for $allThingsPwsh:
So that’s another CommandInfo object right? Nope, as
$allThingsPwsh.GetType() shows us:
So when you get multiple items returned, it’s now an array, of CommandInfo objects. So if we want to see the second item, we get just that entry for $allThingsPwsh:
But as it’s an array of objects, we gets more flexibility, like if we just want to see the path for that entry, we use $allThingsPwsh.Source:
If we just want the paths for all the items, we use
$allThingsPwsh.Source, and we get:
If we just want the name and the path separated by a tab, easily done with
allThingsPwsh.Name + "`t" + $allThingsPwsh.Source:
So yeah, because PowerShell understands objects and arrays better than things like shell, you get a lot of flexibility in the command, saving you from a lot of the endless string/output parsing legerdemain you have to do with shell.
For more info on arrays:
https://docs.microsoft.com/en-us/powershell/scripting/learn/deep-dives/everything-about-arrays?view=powershell-7.2 and https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_arrays?view=powershell-7.2