6 Linux Terminal Tips and Tricks to Get Things Done Quickly

The Linux terminal, often referred to as the command-line interface (CLI), is a powerful tool that, once mastered, can significantly boost your productivity and efficiency. While graphical user interfaces (GUIs) offer visual convenience, the terminal provides a direct and often faster route to managing your system, automating tasks, and interacting with your files. For many seasoned Linux users, the terminal is not just an option but a fundamental aspect of their workflow. Navigating and manipulating your operating system through commands might seem daunting at first, but with a few key tips and tricks, you can transform your command-line experience from intimidating to incredibly empowering. This article from MakeUseOf will delve into six essential Linux terminal tips and tricks designed to help you get things done quickly, enabling you to harness the full potential of your Linux environment.

Mastering Command History: Your Unsung Productivity Hero

One of the most immediate ways to speed up your terminal usage is by effectively leveraging the command history feature. Every command you type is stored, and with the right techniques, you can recall, modify, and re-execute them with remarkable speed, eliminating the need to retype repetitive or complex commands.

Recalling Previous Commands with history and Arrow Keys

The most basic way to access your command history is by using the up and down arrow keys on your keyboard. Pressing the up arrow cycles backward through your previously executed commands, while the down arrow cycles forward. This is incredibly useful for re-running a command you just used or correcting a minor typo from a previous entry.

For a more comprehensive view of your history, the history command itself is invaluable. Typing history into your terminal will display a numbered list of all the commands you’ve entered during your current session and often previous sessions as well, depending on your shell configuration. This list can be quite extensive, so you can also filter it. For instance, history | grep <command> will show only the lines from your history that contain the specified <command>. This is fantastic for finding a specific command you used days ago, like a complex grep or find operation.

Efficient Command Execution with !

The exclamation mark (!) is a powerful shorthand for executing commands from your history.

• !!: This is the most common usage, executing the immediately preceding command. If you made a mistake in your last command, like forgetting sudo, you can often fix it by typing sudo !!. This re-runs the last command with sudo prepended.
• !n: Executes the command with number n from your history list. So, if history shows that the command you want is number 123, you can simply type !123 to execute it.
• !-n: Executes the nth command from the end of the history. !-1 is equivalent to !!, !-2 is the second-to-last command, and so on.
• !string: Executes the most recent command that started with string. For example, !ls will run the last command that began with ls. This is incredibly handy if you remember the beginning of a command but not the exact parameters.
• !?string?: Executes the most recent command that contained string anywhere within it. For example, !?awk? would run the last command that used the awk utility.

Editing and Re-executing Commands with ^

The caret symbol (^) is a lifesaver for making quick edits to your last command. ^old^new replaces the first occurrence of old with new in the previous command and then executes it. For instance, if you typed ls -l mydir and meant to type ls -l my_dir, you could fix it with ^mydir^my_dir. This saves you from retyping the entire command.

Customizing Your History: The .bashrc or .zshrc Files

For advanced users, customizing how your shell handles history is key. You can edit your shell’s configuration file (typically ~/.bashrc for Bash or ~/.zshrc for Zsh) to control the size of your history, how it’s stored, and even enable features like sharing history between multiple terminal sessions. Environment variables like HISTSIZE (number of commands to keep in memory for the current session) and HISTFILESIZE (number of commands to save in the history file) can be set. You might also want to explore HISTCONTROL to prevent duplicate commands or commands starting with a space from being saved.

The Power of Tab Completion: Your Terminal’s Best Friend

Tab completion is arguably the single most significant feature for improving terminal speed and accuracy. It’s the terminal’s intelligent auto-completion feature, capable of suggesting commands, filenames, directory paths, and even options for commands.

How Tab Completion Works

When you start typing a command, filename, or directory name, pressing the Tab key tells the shell to try and complete what you’ve typed.

• If there’s only one possible match: The shell will automatically complete the word. For example, if you type cd D and press Tab, and the only directory in your current location starting with D is Documents, it will instantly change to cd Documents.
• If there are multiple possible matches: The shell will usually provide all possible completions or prompt you to press Tab again to see the list of options. For instance, if you type ls -l T and press Tab, and you have directories named Temp and Testing, it might not complete anything. Pressing Tab again will then list both Temp and Testing as possibilities.

Beyond Filenames: Completing Commands and Options

Tab completion isn’t limited to just filenames and directory names. Many modern shells can also complete:

• Command names: Type the first few letters of a command and press Tab. For example, np followed by Tab might complete to npm or npx.
• Command options/flags: With many commands, if you type the command name followed by a hyphen and a few letters, pressing Tab can show you available options. For example, typing grep -i and pressing Tab might show you all the -i related options for grep. This is incredibly powerful for discovering command functionality without needing to consult the man pages every time.
• Usernames and Hostnames: In commands like ssh or scp, tab completion can often suggest valid usernames and hostnames from your ~/.ssh/config file or known hosts.

Customizing Tab Completion

The flexibility of tab completion can be further extended. Many command-line tools install their own completion scripts that you can enable in your shell configuration. For example, if you use tools like git, docker, or kubectl, you can install their specific completion scripts to greatly enhance tab completion for those commands. This allows you to tab-complete branch names in Git, container names in Docker, or resource names in Kubernetes.

Streamlining with Aliases: Creating Your Own Commands

Aliases are custom shortcuts you can create for frequently used commands or complex command sequences. They allow you to define a short, memorable alias that expands into a longer, more intricate command. This is a cornerstone of efficient terminal operation and significantly reduces the need to remember long, cumbersome commands.

Defining and Using Aliases

Aliases are typically defined in your shell’s configuration file (~/.bashrc or ~/.zshrc). The syntax is simple: alias alias_name='command_to_execute'.

For example:

• alias ll='ls -alF' This creates an alias ll that will execute ls -alF (list all files, including hidden ones, with file type indicators). This is a very common alias that many users create.
• alias update='sudo apt update && sudo apt upgrade -y' For Debian/Ubuntu-based systems, this creates a handy alias to update your package lists and upgrade installed packages.
• alias ..='cd ..' A simple alias to move up one directory.
• alias ...='cd ../..' And another to move up two directories.

Once defined, you simply type the alias name in your terminal, and the shell replaces it with the defined command before executing it.

Listing and Removing Aliases

To see all currently active aliases, simply type alias in your terminal. To remove an alias for the current session, you can use the unalias command, for example, unalias ll. Remember that aliases defined directly in the terminal session are temporary and will be lost when you close the terminal. To make them permanent, they must be added to your shell’s configuration file.

Making Aliases More Powerful: Functions

While aliases are great for simple substitutions, shell functions offer more power. They can accept arguments, contain logic, and perform more complex operations. You can define a function like this:

my_backup() {
  tar -czf "$1_backup_$(date +%Y%m%d).tar.gz" "$1"
}

Then, you could call it with my_backup Documents, which would create a gzipped tar archive of the Documents directory named something like Documents_backup_20231027.tar.gz. Functions offer a significant step up in scripting and automation within the terminal.

Leveraging grep and find: Powerful File Searching and Filtering

The ability to quickly locate files and filter through their content is fundamental to streamlining your workflow. find and grep are two of the most powerful command-line utilities for these tasks.

find Command: Locating Files with Precision

The find command is exceptionally versatile for searching for files and directories based on various criteria.

• Basic Usage: find /path/to/search -name "filename" This command will search for a file named filename starting from /path/to/search and all its subdirectories.
• Case-Insensitive Search: find . -iname "myfile.txt" The -iname option makes the search case-insensitive.
• Finding by File Type: find . -type d -name "config" This finds all directories (-type d) named config. You can use -type f for regular files.
• Finding by Modification Time: find . -mtime -7 This finds files that have been modified in the last 7 days. +7 would find files modified more than 7 days ago.
• Finding by Size: find . -size +10M This finds files larger than 10 megabytes.
• Executing Commands on Found Files: This is where find becomes incredibly powerful. find . -name "*.log" -delete will find all files ending in .log and delete them. Be very careful with the -delete option! A safer way to experiment is using -exec: find . -name "*.tmp" -exec rm {} \;. This finds all .tmp files and executes rm on each one. The {} is a placeholder for the found file, and \; terminates the -exec command.

grep Command: Filtering Text Content

grep is used to search for patterns within text. It’s invaluable for sifting through log files, configuration files, or the output of other commands.

• Basic Usage: grep "pattern" filename This searches for lines containing pattern in filename.
• Case-Insensitive Search: grep -i "pattern" filename
• Recursive Search: grep -r "pattern" /path/to/directory This searches for pattern in all files within the specified directory and its subdirectories.
• Showing Line Numbers: grep -n "pattern" filename This displays the line number along with the matching line.
• Inverting the Match: grep -v "pattern" filename This shows all lines that do not contain pattern. This is excellent for filtering out unwanted information.
• Counting Matches: grep -c "pattern" filename This simply counts the number of lines that contain the pattern.
• Combining with Other Commands: The real power of grep is in piping its output to other commands or piping the output of other commands into grep. For example, ps aux | grep nginx will show all running processes and then filter that list to show only lines containing nginx.

Understanding Input/Output Redirection and Pipes

Pipes (|) and redirection (>, >>, <) are fundamental concepts in Unix-like systems that allow you to chain commands together and control where their input comes from and where their output goes. Mastering these techniques is crucial for automating complex tasks and processing data efficiently.

Pipes (|): Connecting Command Outputs to Inputs

A pipe takes the standard output (stdout) of the command on its left and sends it as the standard input (stdin) to the command on its right.

• Example: ls -l | grep ".txt": This first lists files in a long format (ls -l) and then pipes that output to grep, which filters the list to show only lines containing .txt.
• Chaining Multiple Commands: cat my_file.txt | sort | uniq | grep "important": This example reads a file, sorts its lines, removes duplicate adjacent lines, and then filters for lines containing “important”. This demonstrates how you can build complex data processing pipelines with simple commands.

Standard Output Redirection (> and >>)

• > (Overwrite): The > operator redirects the standard output of a command to a file. If the file exists, it will be overwritten. ls -l > file_list.txt will create file_list.txt (or overwrite it if it exists) with the output of ls -l.
• >> (Append): The >> operator redirects the standard output of a command to a file, appending it to the end of the file if it already exists. echo "Another line" >> file_list.txt will add “Another line” to the end of file_list.txt.

Standard Error Redirection (2>)

Commands can produce two types of output: standard output (stdout) and standard error (stderr). By default, both go to the terminal.

• Redirecting Stderr: command 2> error.log will send any error messages generated by command to the file error.log.
• Redirecting Both Stdout and Stderr: You can redirect both to the same file: command &> all_output.log (or command > all_output.log 2>&1). The 2>&1 syntax means “redirect file descriptor 2 (stderr) to the same place as file descriptor 1 (stdout)”.

Standard Input Redirection (<)

The < operator redirects the standard input of a command from a file.

• Example: sort < unsorted_list.txt. This is equivalent to sort unsorted_list.txt for many commands, but it explicitly shows the input redirection. It’s particularly useful when a command only accepts input via stdin.

Leveraging tmux or screen for Session Management

For anyone who spends a significant amount of time in the terminal, especially when working on remote servers or performing long-running tasks, using a terminal multiplexer like tmux or screen is an absolute game-changer for productivity and resilience.

What is a Terminal Multiplexer?

Terminal multiplexers allow you to create, manage, and switch between multiple virtual terminal sessions within a single physical terminal window. You can detach from a session, leaving it running in the background, and then reattach to it later, from the same or a different terminal.

Key Benefits of tmux and screen

• Persistence: You can start a long-running process (like a code compilation, data download, or script execution), detach from the tmux or screen session, log out of your server, and later log back in and reattach to the session to find your process still running exactly where you left off. This is invaluable for preventing disruptions due to network drops or accidental disconnections.
• Multiple Panes and Windows: Both tmux and screen allow you to split your terminal window into multiple panes (showing different command outputs simultaneously) or create multiple windows (each acting as a separate terminal session). This enables a highly organized workflow, allowing you to monitor logs in one pane while running commands in another, or switch between different projects or tasks with ease.
• Collaboration: Some advanced users can even share tmux or screen sessions, allowing multiple people to see and interact with the same terminal session, which is useful for pair programming or remote assistance.

Getting Started with tmux (A Popular Choice)

tmux is generally considered more modern and flexible than screen.

1. Installation: On most Debian/Ubuntu systems: sudo apt update && sudo apt install tmux. On Fedora: sudo dnf install tmux.
2. Starting a Session: Simply type tmux in your terminal.
3. Creating New Windows: Press Ctrl+b (this is the default prefix key, which you press before other commands) then c to create a new window.
4. Switching Between Windows: Press Ctrl+b then n for the next window, Ctrl+b then p for the previous window, or Ctrl+b then a number (0-9) for a specific window.
5. Splitting Panes:
   • Ctrl+b then % splits the current pane vertically.
   • Ctrl+b then " splits the current pane horizontally.
6. Navigating Panes: Press Ctrl+b then an arrow key (up, down, left, right) to move between panes.
7. Detaching from a Session: Press Ctrl+b then d. Your session will continue running in the background.
8. Reattaching to a Session: If you have only one detached session, type tmux attach. If you have multiple, type tmux ls to see them and then tmux attach -t <session_name>.

Learning the key bindings for tmux or screen is an investment that pays dividends in terminal efficiency and robustness.

Command Chaining with && and ||

Beyond basic pipes and redirection, the logical operators && and || provide sophisticated control over command execution flow, enabling you to build more intelligent and resilient command sequences.

&& (AND Operator): Execute Only on Success

The && operator executes the command on its right only if the command on its left succeeds (returns an exit status of 0). This is incredibly useful for ensuring that a subsequent step in a process only runs if the preceding one completed without errors.

• Example: make && ./my_program
  • First, make is executed to compile my_program.
  • If make completes successfully (exit status 0), then ./my_program is executed.
  • If make fails (e.g., due to compilation errors), ./my_program will not be executed, preventing you from running a program that wasn’t properly built.
• More Complex Chains: sudo apt update && sudo apt upgrade -y && echo "System updated successfully!"
  • This sequence first updates package lists, then upgrades packages, and only if both are successful, it prints a confirmation message. If either apt update or apt upgrade fails, the echo command will not run.

|| (OR Operator): Execute on Failure

The || operator executes the command on its right only if the command on its left fails (returns a non-zero exit status). This is perfect for fallback operations or error handling.

• Example: grep "error" logfile.txt || echo "No errors found in logfile.txt"
  • This command searches for the word “error” in logfile.txt.
  • If grep finds “error”, it succeeds, and the echo command is skipped.
  • If grep does not find “error” (meaning it failed to find the pattern), it returns a non-zero exit status, and the echo command is then executed, informing you that no errors were found.
• Fallback for Commands: command_that_might_fail || alternative_command
  • You could use this to try one method of doing something, and if it fails, automatically try a different method.

Combining && and ||

You can combine these operators to create complex conditional logic. For instance, you might want to try a task, and if it fails, attempt a cleanup:

./configure && make && make install || echo "Build process failed."

In this example, if configure or make fail, the echo command will execute. The make install command would only run if both configure and make succeeded.

Conclusion: Embrace the Terminal for Peak Productivity

Mastering the Linux terminal is an ongoing journey, but by integrating these six key tips and tricks into your daily workflow, you’ll experience a dramatic increase in efficiency and command over your system. From the foundational power of command history and tab completion to the organizational prowess of aliases, the precise searching of find and grep, the fluid data manipulation with pipes and redirection, and the robust session management offered by tmux or screen, you are now equipped with the knowledge to get things done quickly and effectively.

The terminal is not merely a tool; it’s a gateway to deeper understanding and control of your operating system. It empowers you to automate repetitive tasks, troubleshoot problems with greater insight, and interact with your digital environment in a direct and powerful way. By embracing these techniques, you’ll not only save time but also develop a more profound appreciation for the capabilities of Linux. MakeUseOf is committed to helping you unlock your computing potential, and we encourage you to experiment with these commands and explore their vast possibilities. The more you use the terminal, the more indispensable it will become, transforming how you work with Linux and ultimately, boosting your overall productivity.