Why would I create an alias which creates a function?

Here are my 2 cents on this and it represents my personal opinion as well as understanding on the topic.

• Using aliases with functions is to some extent a personal preference of developers. I will add some differences between the two approaches, which may also account for personal preferences of using aliases vs functions
• There are times when most of the things I want to do are possible with aliases itself but only a few require to take a parameter. So instead of mixing aliases with functions, I use an alias with the function itself

Example:

alias kgps='kubectl get pods --all-namespaces | grep '

This works great and I can search my kubernetes pods. Now for deleting these pods, I need to pass the same parameter but in between the command, so I use an alias with a function inside

alias kdp="_(){ kubectl get pods --all-namespaces  | grep \$1 | awk '{print \$2}' | xargs kubectl delete pod; }; _"

So most of my shortcut commands are possible to execute through aliases and only few which needs such things I use aliases with functions.

Aliases vs Functions

Now there are few differences between aliases and functions which I would like to highlight

Aliases can override system commands much more easily compared to functions

If I need to override ls, I can do that much easier with alias

alias ls='ls -altrh'

While a function equivalent of the same would be like below

ls() { command ls -altrh "$@";}ls() { /bin/ls -altrh "$@";}

Aliases intention is mostly for shortcuts

Aliases are majorly used to create shortcut commands while functions are used for a lot of things, complex combinations of commands, auto-completion, bash prompts

Aliases are easier to manage

Run alias command you get a list of currently active aliases

$ alias....vs='vagrant ssh'vu='vagrant up'vus='vu && vs'....

To get the list of functions we need to use declare -f or another similar command

$ declare -f | wc -l  8226$ alias | wc -l  217

Now if I post a partial output of declare -f I get

$ declare -f...vi_mode_prompt_info () {    return 1}virtualenv_prompt_info () {    return 1}work_in_progress () {    if $(git log -n 1 2>/dev/null | grep -q -c "\-\-wip\-\-")    then        echo "WIP!!"    fi}zle-line-finish () {    echoti rmkx}zle-line-init () {    echoti smkx}zsh_stats () {    fc -l 1 | awk '{CMD[$2]++;count++;}END { for (a in CMD)print CMD[a] " " CMD[a]/count*100 "% " a;}' | grep -v "./" | column -c3 -s " " -t | sort -nr | nl | head -n20}

As you can see there are lots of functions which are used but are not relevant to me. While the alias command gives me a very concise output and I can easily see what all is there. In my case, 100% of them are shortcut commands

Escaping aliases and functions syntax is different for system commands

To escape a defined alias you need to prefix it with \ while for functions you need to either use command <originalcommand> or absolute path of the command /bin/originalcommand

Aliases have higher priority over function

Look at the below example

alias ls='echo alias && ls'$ ls() { /bin/ls -al }alias$ lsaliastotal 23173440drwxrwxr-x+ 255 tarunlalwani  staff        8160 Jul 30 22:39 .drwxr-xr-x+ 113 tarunlalwani  staff        3616 Jul 30 23:12 .....

As you can see when we run the ls command, first the alias is used and then the next ls is calling the function.

This becomes also a way of wrapping an exiting function with the same name and re-using the original function inside as well, which can only be done using alias and promotes the format in the question

I found an Ask Ubuntu question about a related topic where one of the answers alleges that this is a misunderstanding of a different design principle: give the function a long and descriptive name, and create a shorter alias for convenience.

This still offers no insight into why you would have the alias redeclare the function every time.

I found this answer too [U&L] In Bash, when to alias, when to script, and when to write a function? which explains the benefit of defining a function in an alias.

The benefit of doing so over declaring a function is that your alias cannot be simply overwritten by source-ing (or using .) a script which happens to declare a same-named function.