Aliases I have known

I have a lot of Bash/Zsh/Fish shell aliases. I’ve carted around a collection of dot files across laptops running both Linux and macOS and for use on systems I’ve managed. I’ve shared some of these, specifically for Docker, in the past. I wanted to do a post detailing some of the other aliases I have in case they are helpful to folks and talk through how to create and manage your aliases.

This is far from a complete list of my aliases; I wanted to explain how some of them work and give samples of some of the cooler things you can do with aliases. To find more aliases, you can check folks’ dotfiles repositories on Github as a starting point.

Aliases and built-in commands

Aliases are created using the alias built-in command. Built-ins are commands that can be run inside the currently running shell process, rather than fork-ed and exec as a sub-process. You can think about running a built-in command like typing inside a file in your editor and a sub-process as opening a new file. Other built-in commands include cd to change directories or echo to write output. You can type:

1

$ man builtin

To see a full list of the built-in commands in your shell.

On Bash, to get specific help on a built-in command, you don’t run man but rather help.

1
2
3
4
5
6
7

$ help cd
cd: cd [-L|[-P [-e]] [-@]] [dir]
    Change the shell working directory.

    Change the current directory to DIR.  The default DIR is the value of the
    HOME shell variable.
...

Sadly, this command doesn’t exist on Zsh, but you can enable the run-help command, which performs a similar function. You can read more about that here.

Creating aliases

The alias command is pretty lightweight to use. It aliases a command or commands to a shortcut. Let’s create our first alias now:

1

$ alias cs="cd ~/src"

Here we’ve created a shortcut, cs, that executes a change of directory to the ~/src directory. If we now execute:

1
2
3

$ cs
$ pwd
~/src

An alias can basically be any command or group of commands; here’s an example using a pipe between two commands.

1

$ alias pss="ps aux | grep 'ssh'"

The above will create an alias that runs ps aux to output currently running processes and pipes the output to grep, which searches for ssh and returns any processes that match.

Running the alias command without any options will return the list of current aliases in the shell.

1
2

$ alias
alias cs='~/src'

This alias will, however, only exist for the duration of this shell session. When you exit the shell, it’ll disappear as if it never was.

Creating permanent aliases

If you want to create permanent aliases, you need to tell your shell about them and ensure they are loaded when your shell session starts. To do this, we generally want to write our aliases into the .bashrc file on Bash shells or the .zshrc file in Zsh shells, both files being located in your home directory.

1
2
3

$ cd ~
$ ls -la .bashrc
-rw-r--r-- 1 james james 3486 Mar 28  2021 .bashrc

Some tutorials will put aliases into the .bash_profile file (or the .zprofile file for Zsh shells) in your home directory. However, the .bash_profile or .zprofile files are only loaded when you launch a new interactive login shell, for example you SSH into a host. If you instead launch an interactive non-login shell, for example by opening your Terminal app, then the .bash_profile file is not loaded and you will not have access to any of your aliases if you place them in there. In this case though, which I also feel is the much more common vector for launching a shell, the .bashrc file is loaded, together with your aliases.

On many platforms, when you add a user, your operating system will create a home directory for that user that contains basic examples of these files, for example, a .bash_profile file and a .bashrc file for Bash shells. The example .bash_profile or .zprofile file will even sometimes contain a command to source the .bashrc or .zshrc file, ensuring your aliases are loaded in every type of shell launch you can perform. But better to be safe and just use the .bashrc or .zshrc files.

Sequential aliases

Another neat trick is sequential aliasing. Typically an alias consists of a single word; for example, our cs alias above is expanded when run to cd ~/src. But we can also chain aliases together to type several in a row and have each expand when executed. This is useful for having a base command and several sets of flags, helping keep your aliases DRY.

1
2
3

alias l="ls "
alias long="-Flas"
alias clm="-CF"

Our first alias, l, is simply the ls command, but suffixed with a single trailing space. Our next two aliases are different flag sets for ls: long to display a long directory listing and clm to display our directory list in column format. We can then use them in combination:

1
2
3
4

$ l long
...
$ l clm
...

Now both aliases will be expanded, allowing us to use a single alias for the primary command and different flag sets depending on our needs. This is useful as sort of entry-level alias variable functionality.

Some aliases

I’m also going to share some of the aliases I’ve collected. I can’t claim credit for writing them all, some I’ve got from others, found on Stackoverflow or Github, and I’ve tried to credit the ones I remember the source.

Directories

The ls command is pretty tepid without flags, and setting a default set of flags makes a lot of sense. I have a few ls aliases I use, starting with an old classic: output in columns, not a list. I default the stock ls command to:

1
2

alias ls="ls -CF"
alias sl="ls -CF"

And because I am monumentally fat-fingered, I also have an alias for sl for when I inevitably type the wrong thing.

I also use another classic:

1

alias ll="ls -lha"

This makes ls display entries, including hidden entries prefixed with . in a list with the disk space values being reported in “human” terms, so 1K instead of 1024.

I also have many directories with many items in them, so I sometimes want to pipe the ls output into a pager, usually less.

1

$ alias lsl="ls -lhFA | less"

I also use some aliases for directory navigation.

1
2
3
4
5

alias ..="cd .."
alias ...="cd ../.."
alias b="cd $OLDPWD"
alias s="cd ~/src"
alias mkdir="mkdir -pv"

The .. aliases are used to go up to the next directory, ... to go up two directories, the b alias returns you to the last directory you were in, and my s alias changes me to the src directory in my home directory. The last alias defaults mkdir directory creation to create intermediate directories as required.

Disks

I also use some aliases for working with disk space, memory, and processes. The first four aliases handle disk, file space, and memory.

1
2
3
4

alias df="df -ha"
alias du="du -ach | sort -h"
alias free="free -t --mega"
alias fm="ps -caxm -orss= | awk '{ sum += $1 } END { print "Resident Set Size: " sum/1024 " MiB" }'"

The first alias runs the df command with my preferred options: human-readable disk spaces values and all mount points. The second alias runs the du command and pipes the output to sort to display the files in whatever directory you specify in a descending human-readable list by file size, including a total.

The third alias is for the free command, which is generally only present on Linux hosts; I specify the output in megabytes and add a total line. The fourth alias exists because the free command annoyingly doesn’t exist on macOS; they expect you to check the Activity Monitor. Instead, this alias returns, roughly, via the ps command and some awk-ing and printing the currently used memory.

I also do a lot of checking of processes and their status via the command line.

1
2
3

alias psm10="ps auxf | sort -nr -k 4 | head -10"
alias psc10="ps auxf | sort -nr -k 3 | head -10"
alias pa="ps aux | grep"

The first two aliases show the top 10 processes by memory and CPU on a host. It doesn’t work on macOS because their ps command doesn’t support the f flag, you can omit that, and the command will broadly work.

The last alias passes my default options for the ps command and pipes it to the grep command. You run the alias and pass it the name of a process, for example:

1
2
3

$ pa containerd
root       806  0.1  1.6 1032236 34420 ?       Ssl  Apr09  95:17 /usr/bin/containerd
root     13054  0.0  4.2 985664 86904 ?        Ssl  Apr21   5:50 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

When run without input, the command will error.

Networking

I also have a selection of commands to automate some basic networking tasks and information.

1
2
3
4

alias ports="sudo lsof -i -n | egrep 'COMMAND|LISTEN|UDP|TCP'"
alias mip="ifconfig en0 | grep inet | grep -v inet6 | cut -d ' ' -f2"
alias myip="curl https://ipecho.net/plain; echo"
alias ping="ping -c 5"

The first alias, ports, uses the lsof command to show every listening UDP and TCP port on the host. You could do a similar thing with netstat or ss, but this version works on both Linux and macOS.

The second alias is MacOS specific and returns the current IP address of your host. You could easily do the same on Linux by specifying the correct interface instead of en0 and tweaking the cut command.

The third alias is a quick and dirty way of showing the public IP address of the host (or whatever router etc., is fronting the Internet in your network). It’ll work on both macOS and Linux. It’s a good example of using more complex operations like querying data from a website or API.

The last alias just adds defaults to the ping command.

Shell and CLI

I also have a few quick aliases for working on the command line in general.

1
2
3

alias h="history"
alias :q="exit"
alias c="code ."

The first alias, h, is a shortcut to the history command, which returns a list of recently run commands.

The second alias uses a Vim shortcut, :q, to run the exit command and exit the running shell. I am so used to quitting things via :q (I also have a variant for :wq for when my muscle memory uses that instead) that this is a useful shortcut.

The last alias, c, runs VSCode in the current directory. This opens a VSCode window in the current working directory. Useful if you want to quickly edit something or open a project from the command line.

Kubernetes

Here’s a short collection of my Kubernetes aliases; I have many others as the kutectl CLI is annoyingly verbose, but these I use all the time.

1
2
3
4
5

alias k="kubectl"
alias ka="kubectl apply -f"
alias kex="kubectl exec -i -t"
alias klo="kubectl logs -f"
alias kn="kubectl get nodes"

Git

A list of aliases wouldn’t be complete without my endless and ever-changing collection of Git shortcuts.

1
2
3
4
5
6
7
8
9

alias gs="git status -sb"
alias gal="git add ."
alias gca="git commit -a -m"
alias gcot="git checkout"
alias gpo="git push -u origin"
alias stash="git stash"
alias glog="git log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"
alias nah="git clean -df && git checkout -- ."
alias hellnah="git reset --hard && git clean -df"

These are a mix of quick shortcuts for adding, committing, and checking out. Also checking the status of a repository and my preferred git log configuration (which I think was modified from this SO answer).

I also have aliases like stash for running git stash and two of my favorites, nah that cleans the repository of modified and unmanaged files and hellnah, which invokes the wrath that is git reset --hard.

Packages

Finally, I have some aliases I use for working with packages and package managers. On Linux, I also have a collection that alias various dnf, yum, and apt-get commands, but these are the ones I use most locally on macOS.

1
2
3

alias pi="pip3 install"
alias bi="brew install"
alias cats="cat package.json | jq '.scripts'"

The pi and bi aliases are shortcuts to pip3 and brew install, respectively.

The last alias is one I use for Node projects. It reads any package.json files in a directory and returns any scripts defined in the file.

Functions? What the hell is a function?

Hopefully, that was useful, and some of those aliases can make your life easier. I can’t claim credit for all, so thanks to the folks who have published their dotfiles and allowed folks to crib from them.

Finally, I have good news and bad news. The good news is aliases are really cool and easy to use. The bad news is that Bash (and Zsh) recommends almost anything more complex than a single command should be defined as a function, not an alias. Don’t panic. We’re going to go into functions in a future post!