Powershell: What's the difference between Alias and Function?

Im setting up my powershell profile to create aliases of commonly used commands. On Microsoft's documentation it says, if I want to make an alias for a command with parameters, I should make the value of the alias a Function that does that.. However, when I type the name of the function in the command line it works just as well as an alias.

In other words, in the above picture, if I typed CD32 it would behave the same as if I typed Go in the command line

So my question is: Why do I use aliases pointing to functions when I could just have a function? Are there feature differences between the two?

• An alias in PowerShell allows you to define an alternative name for another command.

  • Unlike in POSIX-compatible shells such as bash, you cannot include pass-through arguments in its definition - you need a function for that (see below).

  • The typical use case is to define a short alternative name for convenience of interactive invocation; for instance, PowerShell has a built in gc alias for its Get-Content cmdlet. PowerShell even recommends a naming convention for aliases, based on official short alias prefixes for its approved verbs, such as the g for the Get verb in the given example.

  • Another, problematic use is to define aliases named for a different shell's commands; for instance, PowerShell has a built in dir alias for its Get-ChildItem, named for cmd.exe's (Command Prompt's) internal dir command. While that may be somewhat helpful while transitioning from cmd.exe, it only works in very simple invocations, and quickly becomes problematic due to PowerShell's fundamentally different command-line syntax and differing parameter names.

  • Another, unproblematic use is to define an alias for an external executable whose directory isn't listed in the path ($env:PATH); e.g., if you want to execute c:\path\to\foo.exe as just foo without having to add c:\path\to to $env:PATH, you can use Set-Alias foo c:\path\to\foo.exe.

  • Unlike in POSIX-compatible shells such as bash, aliases are (invariably) usable in scripts (*.ps1 files), but their use in scripts is discouraged in the interest of robustness and long-term stability.

• A function, as is to be expected, is a named unit of code that can accept arguments and can perform arbitrary operations.

  • A function is what you need to use if you want to wrap existing commands, by hard-coding pass-through arguments and / or providing additional custom logic around the invocation of the wrapped command.

  • E.g., the following gcir function wraps Get-ChildItem calls with a hard-coded -Recurse argument while passing all supplied arguments through:

    function gcir { Get-ChildItem -Recurse @args }
    

  • See this answer for details and more sophisticated wrapper functions that also support pipeline input and tab-completion.

As for whether it makes sense to define an alias for a function, if implementation of your command requires a function (due to requiring more than just a simple name mapping):

• If all you need is one (short) name for your command, you can define your function directly with that name - no alias needed.

• By contrast, if your function needs a long name, especially an advanced (cmdlet-like) function that adheres to PowerShell's verb-noun naming convention (e.g., Invoke-Foo), and you also want a short name for interactive convenience (e.g., foo), you'll have to also define an alias for that function with that short name (e.g., Set-Alias foo Invoke-Foo).