Why “alias” is my last resort for aliases
65 comments
·March 5, 2025pwagland
watusername
Yes, and this is why I recommend against the alias-y wrappers.
Personally, I like using abbreviations ("abbr") in fish, which automatically expand as you hit space. This is especially helpful when screen sharing: No more "what does this gcob command do" questions!
leojfc
Yeah, I do something kind of similar, using Dash [1] snippets which expand to full commands.
Since I'm almost always on my mac, it means they're available in every shell, including remote shells, and in other situations like on Slack or writing documentation.
I mostly use § as a prefix so I don't type them accidentally (although my git shortcuts are all `gg`-consonant which is not likely to appear in real typing).
BerislavLopac
I was nearly 10 years old (i.e. as a Fish user) when I learned about abbr. I used to use functions for everything. :facepalm:
psychoslave
Came here to mention just this, all the more as the article mention that the author is considering a move to Fish.
lvncelot
Another advantage of using alias: `which [alias]` actually tells you what that alias is mapped to, and not just the location of a script in your bin folder.
darrenf
This is something I've never seen. `which` (at least on the hosts I currently have access to) is its own binary `/usr/bin/which` and unrelated to the shell and its aliases or abbreviations.
`type` is a builtin on both fish and bash though, and does resolve aliases.
[edit] TIL: `zsh` has its own `which`.
BenjiWiebe
Some distros use an alias which pipes all the aliases into 'which', which has a flag that supports reading aliases from stdin.
Fedora does it. It's very convenient.
Graziano_M
On what shell? That doesn't work in bash. I use `type` for that, since it'll tell you if it's on PATH, a function, or an alias
which gdb /opt/homebrew/bin/gdb
~ type gdb gdb is aliased to `gdb -q'
pcthrowaway
In bash this is how I get git completions working (with bash functions rather than aliases):
__git_complete grm _git_rm
grm() {
git rm "${@}"
}
This does seem to ship as part of git now, here[1].
[1]: https://github.com/git/git/blob/6a64ac7b014fa2cfa7a69af3c253...
lvncelot
zsh for me
~ ▸ which k
k: aliased to kubectl
srveale
`alias | grep [alias name]` works as well, for me at least
saghm
I remember years ago seeing a trick related to this to allow aliases after `sudo` (which I think by default won't recognize them due to running as a separate user) by doing `alias sudo="sudo ".
modeless
This doesn't work for me in Ubuntu 22.04. Is it a recent feature of bash?
mqus
This is a feature in zsh (I don't think it works in bash and the autocomplete in bash is also a bit inferior to the zsh one)
tasn
I came here to say the same thing. I'm also not convinced about the instant reload aspect. You can always just define your aliases in a different file and source it when updating aliases (how often does that happen anyway?), source your .zshrc, or just open a new terminal window.
chrisfinazzo
Sourcing .zshrc works reasonably well. I have the following at the end of setup.sh -- which creates symlinks and sets up other configurations.
makeLinks does most of the work, then sets Homebrew's zsh as the default shell -- this currently runs in bash, so it probably will need to be updated at some point -- and everything gets reloaded.
makeLinks && chsh -s /usr/local/bin/zsh
exec $SHELL && brew doctoralkh
I have an alias reload="exec zsh" for fast reloading. Admittedly, this does wreck up everything set up locally but I doubt you will be modifying ~/.[zsh|bash]rc file often
chime
I have alias s='source ~/.zshrc'.
ale42
I'm not sure I understand this point:
> I use Bash for a lot of my scripts, but not all. For example
> I have a note-taking script called ~/bin/note which I didn’t
> want to write in Bash, so I wrote it in Python instead. With
> an alias, I’d have to write it in Zsh.
eqvinox
There isn't a well-defined / binary boundary to an "actual script"; I'm assuming this "note" thing is something like a 10-liner in Python. It's simply two curves of scripting in sh/bash/zsh becoming more difficult vs. Python starting with more effort but a more shallow curve — at some point the curves cross. But that crossover point is different for each person, and the other option doesn't immediately become impossible.
null
latexr
> When I create, update, or delete an alias, I have to reload my `.zshrc`.
Only if you need the change to be available immediately in the tab you’re on. Which you can ensure, appropriately, with an alias:
alias z='"${EDITOR}" ~/.zshrc && source ~/.zshrc'
noahjk
Here's what I use in my .zshrc with VS Code:
alias reload="source ~/.zshrc >/dev/null"
alias zshconfig="code --wait --new-window ~/.zshrc && reload"
latexr
On macOS, you can do that for any GUI editor by using the `open` command with the `-W` and `-n` flags. See `man open` for details.
thor_molecules
I reach for the ~/bin/thing approach when I want the utility to be useable from vim.
For example, if I define an alias thing, vim won't know about it.
But as a executable on my $PATH, I can do any of the following:
:%!thing
:'<'>!thing
:.!thing
#!/bin/sh
python -m json.tool --indent 2
:%!fmtjson
tester457
For more power try fish's abbreviations.
With `--position anywhere` you can expand an abbreviation even if it's not at the beginning of a line.
dmd
Another great advantage of fish abbreviations is your history shows the actual command that was run (and in fact as soon as you've typed it, it expands, so you SEE what you're running).
jacobsenscott
Yes, essentially on the fly editable aliases. Fish is so good. I assume there's a zsh plugin that mimics that functionality - zsh people should try it.
mattgreenrocks
I like putting my "aliases" into the functions directory of my config.
I have one that uses podman if it's available when I type `docker`. If I ever specifically need Docker I can use the fully-qualified path. I have a similar trick for `nvim`/`vim`.
watusername
This is the right way. I mentioned in another comment, but abbreviations also shine when screen sharing: Everyone can follow along quickly without having to ask the "what does this gcob command do" questions.
sisk
zsh also supports the "alias anywhere" concept (their term is "global alias") by using the `-g` flag.
alias -g ag='2>&1 | grep'
some-command ag 'words' # equivalent to: some-command 2>&1 | grep 'words'alkh
Yeah, it's very convenient. Here are a few of mine(tested on OS X):
alias -g L="| less"
alias -g T="| tee"
alias -g C="| pbcopy"
alias -g @all="> /dev/null 2>&1"
if command -v rg > /dev/null; then
alias -g G="| rg"
else
alias -g G="| grep"
figthink
It seems like a lot of effort to replace just `alias g=git?` Not to mention the fact that you have to move the script files across systems as well.
I think the target is mostly cross-shell porting here.
andoveragain
Sounds like overengineering. If you just need a shortcut for a command, that's exactly what aliases are for. If you need something more sophisticated, you probably are going to lean to scripts or functions.
eqvinox
Pretty much agree with most. I am wondering about paths and locations; there's now ~/.local/bin which is where e.g. a user-wide "pip install" would put things [when used without a venv]… ~/bin is not such a "standardized" location. I kinda started using both and am a bit torn now…
acatton
In this example, it's easier to just do "ln -s /usr/bin/git ~/bin/g" instead of creating a bash script...
But that's just my opinion.
adrian_b
True, but I think that the author did not mean this as a real useful example.
At least for myself, the main benefit of aliases is not to abbreviate the command name, but to change the default command-line options.
I strongly dislike the default command-line options of most UNIX utilities, e.g. cp, mv, rm and the like, so I never invoke them directly, but only through aliases that use what I consider to be the correct default options (for instance I consider that the default for any kind of copy command must be to make an exact copy of the source, instead of losing any part of the original information).
null
null
arisudesu
Surely this is possible way to alias commands, but keep in mind that PATH extensions are made available not only in shell, but to all programs started from it, well, because it is environ. Whereas aliases are available only for use inside shell, but they're not executable by programs started from it. They are not the same.
The other advantage that the article misses for aliases is that completions will work through aliases. So, in the case give for `alias g=git` typing `g <tab>` will give you the bash/zsh completions for git. You _can_ do this for the script as well, but then you need to code that up separately.