{"id":6402,"date":"2023-12-12T13:12:46","date_gmt":"2023-12-12T20:12:46","guid":{"rendered":"https:\/\/ioflood.com\/blog\/?p=6402"},"modified":"2024-04-26T12:15:48","modified_gmt":"2024-04-26T19:15:48","slug":"history-linux-command","status":"publish","type":"post","link":"https:\/\/ioflood.com\/blog\/history-linux-command\/","title":{"rendered":"‘history’ in Linux: Your Linux Terminal Command Guide"},"content":{"rendered":"
\n
\"Image<\/figure>\n<\/div>\n

Ever found yourself wishing you could recall a previously used command in Linux? You’re not alone. Many users find themselves needing to revisit previously executed commands, but aren’t sure how to do so. Think of the ‘history’ command in Linux as your personal time machine, allowing you to travel back in your command line history.<\/p>\n

In this guide, we’ll take you on a journey through the ‘history’ command in Linux<\/strong>, from its basic usage to more advanced techniques. We’ll explore how to use the ‘history’ command, how to navigate through your command history, and even how to leverage it for more complex tasks.<\/p>\n

So, let’s dive in and start mastering the ‘history’ command in Linux!<\/p>\n

TL;DR: What is the History Command in Linux and How Do I Use It?<\/h2>\n

\n The 'history'<\/code> command in Linux is a built-in shell command that displays your command line history. It is used with the syntax, history [options]<\/code>.\n<\/p><\/blockquote>\n

Here’s a basic example of how to use it:<\/p>\n

# Previously Used Commands\n$ ls\n$ cd Documents\n$ mkdir Projects\n\n# Call the history command to display command history\n$ history\n\n# Expected Output\n# 1  ls\n# 2  cd Documents\n# 3  mkdir Projects\n# 4  history\n\n<\/code><\/pre>\n
In this example, we start by performing various actions like listing files, navigating to a directory, and creating a new directory. Then, we use the history command to see a list of all the commands we’ve typed in so far.<\/p>\n
\n  If you’re interested in learning more about the ‘history’ command, including advanced usage scenarios and related commands, continue reading. We’ll dive deeper into the topic, providing practical examples and tips along the way.\n<\/p><\/blockquote>\n
Understanding the Basics of the History Command<\/h2>\n
The ‘history’ command in Linux is a built-in shell command that displays your command line history. It’s a powerful tool that can save you time and effort, especially if you often find yourself executing the same commands over and over again.<\/p>\n
When you type ‘history’ into your terminal, the command will return a list of previously executed commands, each with a corresponding number. This number is known as the command’s history ID, and it can be used to quickly re-execute a command from your history.<\/p>\n
Let’s take a look at an example:<\/p>\n
$ history\n\n# Output:\n# 1  ls\n# 2  cd Documents\n# 3  nano file.txt\n# 4  gcc program.c\n# 5  .\/a.out\n# 6  history\n<\/code><\/pre>\n
In this example, we simply typed ‘history’ into the terminal, and the command returned a list of previously executed commands. The number next to each command is its history ID. For instance, the ‘ls’ command has a history ID of 1, while the ‘history’ command itself has a history ID of 6.<\/p>\n
One of the key advantages of the ‘history’ command is its simplicity. It’s easy to use and understand, even for beginners. However, it’s important to note that the ‘history’ command only displays the history of the current terminal session by default. If you close your terminal and open a new one, the history command will only show the commands executed in the new session.<\/p>\n
In the next section, we’ll explore how to use the ‘history’ command in more advanced ways, such as searching your command history or re-executing commands from your history.<\/p>\n
Delving into Advanced Usage of the History Command in Linux<\/h2>\n
As you become more comfortable with the basic ‘history’ command, you’ll find that its true power lies in its advanced features. The ‘history’ command’s flexibility allows it to handle more complex tasks, such as searching your command history or re-executing commands from your history. Let’s explore some of these advanced uses.<\/p>\n
Before we dive into the advanced usage of the ‘history’ command, let’s familiarize ourselves with some of the command-line arguments or flags that can modify the behavior of the ‘history’ command. Here’s a table with some of the most commonly used ‘history’ command arguments.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n
Argument<\/th>\nDescription<\/th>\nExample<\/th>\n<\/tr>\n<\/thead>\n
-c<\/code><\/td>\nClears the history list.<\/td>\nhistory -c<\/code><\/td>\n<\/tr>\n
-d offset<\/code><\/td>\nDeletes the history entry at position offset.<\/td>\nhistory -d 2<\/code><\/td>\n<\/tr>\n
-a<\/code><\/td>\nAppends history lines from this session to the history file.<\/td>\nhistory -a<\/code><\/td>\n<\/tr>\n
-n<\/code><\/td>\nReads all history lines not already read from the history file.<\/td>\nhistory -n<\/code><\/td>\n<\/tr>\n
-r<\/code><\/td>\nReads the history file and appends the contents to the history list.<\/td>\nhistory -r<\/code><\/td>\n<\/tr>\n
-w<\/code><\/td>\nWrites the current history to the history file.<\/td>\nhistory -w<\/code><\/td>\n<\/tr>\n
-p arg<\/code><\/td>\nPerforms history substitution on arg and displays the result on the standard output.<\/td>\nhistory -p '!2'<\/code><\/td>\n<\/tr>\n
-s args<\/code><\/td>\nAppends args to the history list as a single entry.<\/td>\nhistory -s 'cd ~\/Documents'<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Now that we have a basic understanding of ‘history’ command line arguments, let’s dive deeper into the advanced use of the ‘history’ command.<\/p>\n
Searching Command History with Grep<\/h3>\n
One of the most powerful ways to use the ‘history’ command is in conjunction with ‘grep’ to search your command history. This can be incredibly useful when you’re trying to find a specific command that you’ve used in the past. Here’s how you can do it:<\/p>\n
$ history | grep 'ls'\n\n# Output:\n# 1  ls\n# 7  ls -l\n# 10 ls -a\n<\/code><\/pre>\n
In this example, we’re using ‘grep’ to search our command history for any instance of the ‘ls’ command. The output shows all the commands that include ‘ls’, along with their history IDs.<\/p>\n
Re-executing Commands from History<\/h3>\n
Another powerful feature of the ‘history’ command is the ability to quickly re-execute commands from your history. This can be done using the ‘!’ symbol followed by the history ID of the command you want to re-execute. Here’s an example:<\/p>\n
$ !2\n\n# Output:\n# cd Documents\n<\/code><\/pre>\n
In this example, we’re re-executing the command with a history ID of 2, which is ‘cd Documents’. This can be a real time-saver, especially when working with long or complex commands.<\/p>\n
Understanding the History Command’s Limitations<\/h3>\n
While the ‘history’ command is incredibly useful, it’s important to understand its limitations. By default, the ‘history’ command only displays the history of the current terminal session. If you close your terminal and open a new one, the ‘history’ command will only show the commands executed in the new session. However, this behavior can be modified using the ‘history’ command’s arguments, as we discussed earlier.<\/p>\n
In the next section, we’ll explore some alternative approaches to interacting with your command history, including other related commands and functions.<\/p>\n
Exploring Alternatives: Beyond the History Command<\/h2>\n
While the ‘history’ command is a powerful tool for interacting with your command history in Linux, it’s not the only tool available. There are other commands and functions such as ‘fc’ and ‘ctrl-r’ that offer alternative ways to interact with your command history. Let’s explore these alternatives and how they can be used.<\/p>\n
Using the ‘fc’ Command<\/h3>\n
The ‘fc’ command, short for ‘find command’, is another built-in shell command for interacting with your command history. It’s more advanced than the ‘history’ command and offers a wider range of features. For example, the ‘fc’ command allows you to edit commands from your history before re-executing them.<\/p>\n
Here’s how you can use the ‘fc’ command:<\/p>\n
$ fc -l 5 7\n\n# Output:\n# 5  .\/a.out\n# 6  history\n# 7  ls -l\n<\/code><\/pre>\n
In this example, we’re using the ‘fc’ command with the ‘-l’ argument to list the commands with history IDs 5 through 7. The output shows these commands, just like the ‘history’ command would.<\/p>\n
Leveraging ‘ctrl-r’ for Command Search<\/h3>\n
Another alternative for interacting with your command history is the ‘ctrl-r’ function. This function allows you to search your command history in real-time, right from your command line. Here’s how it works:<\/p>\n
    \n
  1. Press ‘ctrl-r’ on your keyboard.<\/li>\n
  2. Start typing the command you’re looking for.<\/li>\n
  3. As you type, your command line will update to show a matching command from your history.<\/li>\n
  4. When you see the command you’re looking for, press ‘Enter’ to execute it.<\/li>\n<\/ol>\n
    While ‘ctrl-r’ doesn’t provide a visual list of commands like the ‘history’ or ‘fc’ commands, it can be faster and more efficient for finding and executing commands from your history.<\/p>\n
    Making the Right Choice<\/h3>\n
    When it comes to interacting with your command history in Linux, the ‘history’ command is just the beginning. Depending on your needs, you might find that the ‘fc’ command or ‘ctrl-r’ function is a better fit. It’s all about finding the right tool for the job.<\/p>\n
    In the next section, we’ll cover some common troubleshooting tips and considerations for using these commands and functions.<\/p>\n
    Navigating Common Challenges with the History Command<\/h2>\n
    While the ‘history’ command and its alternatives are powerful tools, they’re not without their challenges. In this section, we’ll cover some common issues you might encounter while using these commands, as well as their solutions. We’ll also share some tips for optimizing your use of these tools.<\/p>\n
    Addressing Command History Limitations<\/h3>\n
    One common issue with the ‘history’ command is its session-based limitation. By default, the ‘history’ command only displays the history of the current terminal session. If you close your terminal and open a new one, the ‘history’ command will only show the commands executed in the new session.<\/p>\n
    However, you can overcome this limitation by appending your session’s history to the history file before closing the terminal. Here’s how you can do it:<\/p>\n
    $ history -a\n<\/code><\/pre>\n
    In this example, the ‘-a’ argument tells the ‘history’ command to append the current session’s history to the history file. Now, even if you close your terminal and open a new one, you can still access your previous session’s history using the ‘history’ command.<\/p>\n
    Understanding !: Event not found Errors<\/h3>\n
    When re-executing commands from your history using the ‘!’ symbol followed by the history ID, you might encounter an error message like this:<\/p>\n
    $ !1000\n\n# Output:\n# -bash: !1000: event not found\n<\/code><\/pre>\n
    This error occurs when there’s no command in your history with the specified history ID. To avoid this error, you can first check your command history using the ‘history’ command to ensure the history ID exists.<\/p>\n
    Optimizing Your Command History<\/h3>\n
    To make the most of your command history, consider customizing your history settings. For instance, you can increase the size of your command history by modifying the ‘HISTSIZE’ environment variable in your bash profile. Here’s how you can do it:<\/p>\n
    $ echo 'export HISTSIZE=5000' >> ~\/.bashrc\n$ source ~\/.bashrc\n<\/code><\/pre>\n
    In this example, we’re increasing the size of our command history to 5000 commands. The change is made in the ‘.bashrc’ file, which is sourced to apply the new setting.<\/p>\n
    Remember, the ‘history’ command and its alternatives are powerful tools for interacting with your command history in Linux. With a good understanding of these commands and how to troubleshoot common issues, you can save time and effort in your daily tasks.<\/p>\n
    Diving Deeper: The Linux Command Line and Command History<\/h2>\n
    To fully understand the ‘history’ command and its alternatives, it’s important to have a solid grasp of the Linux command line and the concept of command history. Let’s delve deeper into these fundamentals.<\/p>\n
    The Linux Command Line: A Powerful Tool<\/h3>\n
    The Linux command line, also known as the terminal or shell, is a powerful interface that allows you to interact with your computer. Unlike graphical user interfaces, the command line provides a direct line of communication with your system. It allows you to execute commands, navigate directories, manipulate files, and much more.<\/p>\n
    Here’s a simple example of using the command line to navigate to a directory and list its contents:<\/p>\n
    $ cd ~\/Documents\n$ ls\n\n# Output:\n# file1.txt  file2.txt  directory1\n<\/code><\/pre>\n
    In this example, we’re using the ‘cd’ command to navigate to the ‘Documents’ directory, and then the ‘ls’ command to list the contents of the directory. The output shows two files and one directory within the ‘Documents’ directory.<\/p>\n
    The Concept of Command History<\/h3>\n
    Command history is a feature of the Linux command line that keeps a record of the commands you’ve previously executed. This can be incredibly useful when you’re working with complex commands or scripts, as you can easily revisit and re-execute previous commands.<\/p>\n
    Here’s an example of how command history works. Let’s say you execute the following commands in your terminal:<\/p>\n
    $ cd ~\/Documents\n$ ls\n$ nano file1.txt\n$ gcc program.c\n$ .\/a.out\n$ history\n\n# Output:\n# 1  cd ~\/Documents\n# 2  ls\n# 3  nano file1.txt\n# 4  gcc program.c\n# 5  .\/a.out\n# 6  history\n<\/code><\/pre>\n
    In this example, we’ve executed several commands, and then used the ‘history’ command to display our command history. The output shows a list of the commands we’ve executed, each with a corresponding history ID.<\/p>\n
    Understanding the Linux command line and the concept of command history is crucial for mastering the ‘history’ command and its alternatives. With these fundamentals in mind, you can leverage the power of command history to improve your productivity and efficiency in the terminal.<\/p>\n
    Applying the History Command in Larger Contexts<\/h2>\n
    The ‘history’ command is not just a tool for individual use in a terminal session. It can be a valuable asset in larger scripts or projects where command repetition is common. By leveraging the ‘history’ command, you can streamline your workflow and make your scripts more efficient.<\/p>\n
    Integrating History Command in Scripts<\/h3>\n
    Consider a scenario where you have a script that executes a series of commands. If you need to debug the script, the ‘history’ command can be a valuable tool. It can help you track the sequence of commands executed and identify any issues. Here’s an example:<\/p>\n
    #!\/bin\/bash\n\necho 'Running script...'\ncd ~\/Documents\nls\nnano file1.txt\ngcc program.c\n.\/a.out\nhistory\n<\/code><\/pre>\n
    In this script, the ‘history’ command is used at the end to display the commands executed during the script’s run. This can be especially useful for debugging and tracking purposes.<\/p>\n
    Complementary Commands and Functions<\/h3>\n
    The ‘history’ command often works in conjunction with other commands and functions. For instance, the ‘alias’ function can be used to create shortcuts for frequently used commands. This can be a time-saver, especially when working with the ‘history’ command. Here’s an example:<\/p>\n
    $ alias h='history'\n$ h\n\n# Output:\n# 1  cd ~\/Documents\n# 2  ls\n# 3  nano file1.txt\n# 4  gcc program.c\n# 5  .\/a.out\n# 6  history\n# 7  alias h='history'\n# 8  h\n<\/code><\/pre>\n
    In this example, we’re creating an alias ‘h’ for the ‘history’ command. Now, instead of typing ‘history’, we can simply type ‘h’ to display our command history.<\/p>\n
    Further Resources for Mastering the History Command<\/h3>\n
    Want to delve deeper into the ‘history’ command and related topics? Here are some resources that offer more in-depth information:<\/p>\n
      \n
    1. GNU Bash Manual<\/a>: The official manual for the GNU Bash shell, which includes detailed information about the ‘history’ command and other built-in shell commands.<\/p>\n<\/li>\n
    2. \n
      Linux Command Library<\/a>: A comprehensive library of Linux commands, including the ‘history’ command and its usage.<\/p>\n<\/li>\n
    3. \n
      The Linux Documentation Project<\/a>: A project aimed at documenting various aspects of Linux, including the command line and shell scripting.<\/p>\n<\/li>\n<\/ol>\n
      Wrapping Up: Recalling Linux Commands with ‘history’<\/h2>\n
      In this comprehensive guide, we’ve delved into the depths of the ‘history’ command in Linux, a powerful tool that allows you to recall and reuse previously executed commands.<\/p>\n
      We began with the basics, learning how to use the ‘history’ command to display a list of previously executed commands. We then ventured into more advanced territory, exploring how to search your command history with ‘grep’, re-execute commands from your history, and manage your command history with various command-line arguments.<\/p>\n
      Along the way, we tackled common challenges you might encounter when using the ‘history’ command, such as session-based limitations and ‘event not found’ errors, providing you with solutions and workarounds for each issue.<\/p>\n
      We also looked at alternative approaches to interacting with your command history, including the ‘fc’ command and ‘ctrl-r’ function. Here’s a quick comparison of these methods:<\/p>\n\n\n\n\n\n\n\n
      Method<\/th>\nPros<\/th>\nCons<\/th>\n<\/tr>\n<\/thead>\n
      history<\/td>\nEasy to use, displays command history with corresponding IDs<\/td>\nOnly displays current session’s history by default<\/td>\n<\/tr>\n
      fc<\/td>\nMore advanced, allows editing of commands before re-execution<\/td>\nMore complex than ‘history’<\/td>\n<\/tr>\n
      ctrl-r<\/td>\nAllows real-time search of command history<\/td>\nDoesn’t provide a visual list of commands<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
      Whether you’re just starting out with the ‘history’ command or you’re looking to level up your command line skills, we hope this guide has given you a deeper understanding of the ‘history’ command and its capabilities.<\/p>\n
      With its balance of simplicity and power, the ‘history’ command is a valuable tool for any Linux user. Happy coding!<\/p>\n","protected":false},"excerpt":{"rendered":"
      Ever found yourself wishing you could recall a previously used command in Linux? You’re not alone. Many users find themselves needing to revisit previously executed commands, but aren’t sure how to do so. Think of the ‘history’ command in Linux as your personal time machine, allowing you to travel back in your command line history. […]<\/p>\n","protected":false},"author":1,"featured_media":13591,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[124,3,9],"tags":[],"class_list":["post-6402","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-bash","category-linux","category-sysadmin","cat-124-id","cat-3-id","cat-9-id","has_thumb"],"_links":{"self":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts\/6402","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/comments?post=6402"}],"version-history":[{"count":9,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts\/6402\/revisions"}],"predecessor-version":[{"id":19222,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts\/6402\/revisions\/19222"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/media\/13591"}],"wp:attachment":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/media?parent=6402"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/categories?post=6402"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/tags?post=6402"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}