Creating Shortcuts with Aliases and Functions

Bash lets you define your own versions of commands, either through aliases or functions.

Aliases let you create shortcuts for commands or override the default options for existing commands. You define them with the alias command, but it’s better to define them in your ~/.bashrc file. Let’s define some aliases.

Open your ~/.bashrc file in nano:

Let’s create an alias for ls -alh so you can avoid typing it out. Add this line to the end of the ~/.bashrc file to define an alias called ll:

Save the file and exit the editor. Then source the file to apply the changes:

Try running the ll alias:

You can use this any time you want a long listing.

You can make an alias for any command you’d like. Let’s add an alias to display your public IP address quickly. Open the ~/.bashrc file again:

Add this alias to the file which fetches your public IP address from an external website:

You’ll learn how this command works in ​Making Web Requests with cURL​.

Save the file, exit the editor, and then source the file to apply the changes to the current shell:

Try out your new alias:

Aliases you create won’t be available if you use the sudo command.

Try it out:

By default, Bash doesn’t look beyond the first word for any aliases, but you can fix that by adding an alias for sudo. Open up the ~/.bashrc file again:

Add this alias to the file:

Note the space after sudo. By leaving a space as part of the command, Bash will look at the next word to see if it’s an alias, which means the ll alias will now work.

Save the file, exit the editor, and then source the ~/.bashrc file to apply the changes. Then try the command again. This time it works:

As you can see from the sudo alias, you can use an alias to override a command with new behavior. So if you always want a long listing when you run ls, you can do that. Just define the alias ls like this:

Now when you type ls, you’ll get the long listing:

But don’t worry; the old behavior is still available. All you have to do is prefix the command with :

And you can remove the alias with the unalias command:

Aliases have some limitations. First, they’re really only designed to either redefine or point to a different command. Arguments you pass to an alias get forwarded along.

If you need more flexibility, you can define functions. Let’s explore this by creating a new function called mcd that creates a directory and navigates to it in a single command. You’ve probably wanted something like this every time you’ve created a new folder and had to navigate to it. Open the ~/.bashrc file in nano:

To declare a function, use the function keyword, followed by the name of the function and the function body, similar to how you’d define a function in many other programming languages. Add this to the file to define the mcd function:

The $1 variable is a reference to the argument passed to the mcd function when it’s called. It’ll be the name of the directory we want to create and switch to.

If you’re defining a small function like this, you can write it in only one line of code:

Note the semicolon after the cd command. That’s necessary if you’re creating a one-line function. Another difference here is that this definition doesn’t use the function keyword. You don’t actually need the function keyword when defining a function. whether it’s simple or complex, but it’s easier for others to follow what you’re doing if you use it, so I recommend including it.

Save the file, exit the editor, and source the file with source ~/.bashrc. Then try it out:

You can make more complex functions than this. Let’s create a function that displays info about your environment. You’ll use the uname -a command to get OS info, the free command to display available memory, and you’ll use curl icanhazip.com to fetch your public IP address. You’ll then use echo with the -e flag to preserve new lines so you get a nice-looking output.

Open your .bashrc file:

Add this function to the file:

If you want to try this on macOS, replace the free command in this function with top -l 1 -s 0 | grep PhysMem, as macOS doesn’t have the free command.

Save the file, exit the editor, source your .bashrc file, and run the command:

You can put all sorts of logic inside of these functions, including conditional statements.

Let’s make a function named less that overrides the real less command. When you call less and pass it a file, you’ll display the file with line numbers. If you pipe data to the less command from another program, you’ll keep the original behavior. It sounds a little like an alias, but by using a function, you can add logic to see how the function was invoked and specify different options depending on whether it’s called directly or if it’s receiving data from standard input.

To do this in a somewhat naive way, you’ll check to see if the standard input stream is connected to a terminal. In other words, you’ll check to see if the input is coming from a command the user typed, rather than from another program.

The expression [ -t 0 ] is how you test that file descriptor 0, or standard input, is connected to your terminal. You can use if-else statements in your functions to evaluate boolean expressions like this. Here’s how that looks:

So, to make the less command show line numbers unless you pipe data, add this function declaration to your ~/.bashrc file:

Now, when you call less, you’re not calling the actual less program; you’re calling this function. This function will then test to see if the input came from the connected terminal or from a pipe. If it came from a connected terminal, it calls the actual less command with the -N option, enabling line numbers. $@ refers to all of the arguments you passed to less when you invoked it. Notice that we use command less inside the function. This ensures that we’re calling the actual less command. This is a safe way to wrap built-in commands with your own functions to extend their behavior.

Save your ~/.bashrc file and apply the changes using source ~/.bashrc. Now try it out by using less to view a file. You’ll have it display the nano.html file you created earlier in this chapter:

Press q to quit less and return to the prompt.

Now invoke less by sending data to your less function through standard input:

This function demonstrates how you can add conditional logic, but it’s not a perfect test. In some situations it won’t give you the behavior you want because the test will think you are using a pipe, such as when used in command substitution.

You’ll learn about command substitution in the next chapter.

Since this function has some side effects, you should remove it from your ~/.bashrc file before moving forward, or rename it so it doesn’t conflict with the built-in less command and surprise you later.