Why would I create an alias which creates a function?
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.
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
$ ls
alias
total 23173440
drwxrwxr-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.