{"id":79738,"date":"2025-06-02T11:17:12","date_gmt":"2025-06-02T11:17:12","guid":{"rendered":"https:\/\/mailinvest.blog\/index.php\/2025\/06\/02\/13-time-saving-linux-terminal-tricks-you-should-be-using\/"},"modified":"2025-06-02T11:18:27","modified_gmt":"2025-06-02T11:18:27","slug":"13-time-saving-linux-terminal-tricks-you-should-be-using","status":"publish","type":"post","link":"https:\/\/mailinvest.blog\/index.php\/2025\/06\/02\/13-time-saving-linux-terminal-tricks-you-should-be-using\/","title":{"rendered":"13 Time-Saving Linux Terminal Tricks You Should Be Using"},"content":{"rendered":"

<\/a>\n<\/p>\n

\n

When utilizing the Linux terminal, we frequently make errors. At different instances, duties really feel simply plain tedious. Luckily, there are lots of terminal methods that make it easier to amend these errors and carry out the tedious duties simply. Let’s discover a few of these methods on this information.<\/p>\n

<\/p>\n

\n 13 <\/span>
\n
\n Run the Earlier Command With sudo
\n <\/span>
\n <\/h2>\n

We\u2019ve all been there. You kind a command, hit Enter, and get a \u201cPermission denied\u201d message. You understand that you just forgot to prefix it with sudo<\/a>. As an alternative of retyping the entire thing, you should use a neat little trick:<\/p>\n

sudo !!<\/pre>\n
This tells the shell to rerun your final command, however this time, with sudo. The !! image is a part of Bash historical past enlargement. It expands to the complete earlier command. So, in case your final command was apt replace<\/strong>, typing !!<\/code> would successfully run apt replace<\/strong>. And sudo !!<\/strong> turns into:<\/p>\n
sudo apt replace<\/pre>\n
\n
\n
\n        \"Using<\/p>\n<\/picture>\n<\/figure><\/div>\n<\/p><\/div>\n
 It\u2019s an actual time-saver, particularly once you’re deep right into a workflow and neglect to raise privileges.<\/p>\n
\n            12 <\/span>
\n        
\n                            Run Instructions With out Leaving a Hint
\n                    <\/span>
\n       <\/h2>\n
Ever run a command you\u2019d relatively not have logged in your historical past? Possibly you are utilizing a secret token, experimenting with a dangerous command, or simply attempting one thing you are undecided about. In Bash, there\u2019s a surprisingly easy technique to hold a command out of your historical past. Simply begin it with an area.<\/p>\n
Here is an instance of my command historical past.<\/p>\n
\n
\n
\n        \"An<\/p>\n<\/picture>\n<\/figure><\/div>\n<\/p><\/div>\n
Now, after operating a command beginning with an area, it will not get added to the historical past.<\/p>\n
\n
\n
\n        \"An<\/p>\n<\/picture>\n<\/figure><\/div>\n<\/p><\/div>\n
As you’ll be able to see, that final echo command<\/a> is to not be discovered. This trick depends on a Bash characteristic known as HISTCONTROL. By default, many methods have HISTCONTROL set to both ignorespace or ignoreboth. These settings inform Bash to disregard instructions that begin with an area when writing historical past.<\/p>\n
\n            11 <\/span>
\n        
\n                            Use the Argument From the Earlier Command
\n                    <\/span>
\n       <\/h2>\n
Ever typed out a protracted file identify, then wanted to make use of it once more within the subsequent command? As an alternative of copying and pasting (or retyping,) simply hit Alt+interval (.) and it’ll insert the final argument from the earlier command proper the place your cursor is. It really works in most Bash shells, and it\u2019s particularly useful for instructions that work on the identical file or listing time and again.<\/p>\n
For instance, you would possibly difficulty this command:<\/p>\n
mkdir really_long_directory_name_with_underscores<\/pre>\n
Then you possibly can kind cd<\/strong> and hit Alt+. to alter directories to the one you simply made.<\/p>\n
One other widespread scenario the place you might use that is once you extract a archive file and wish to take away it. For those who ran this command:<\/p>\n
tar -xvf archive_name.tar.gz<\/pre>\n
You can simply kind rm<\/strong> and press Alt+. to delete the archive. You may press this shortcut a number of instances to cycle via earlier arguments from earlier instructions.<\/p>\n
\n
\t\t<\/p>\n
\n
\n
\n
\n        \"Linux<\/p>\n<\/picture>\n<\/figure><\/div>\n<\/p><\/div>\n<\/p><\/div>\n
\t\t<\/a><\/p>\n
                    Associated<\/span><\/p>\n
\n
\n
\t\t
\n\t\t\tThe 8 Types of Linux Terminal Programs: Do You Know Them All?
\n\t\t<\/a>
\n\t<\/h5>\n
The best way to inform your filters out of your TUIs.<\/p>\n<\/p><\/div>\n<\/p><\/div>\n
\n            10 <\/span>
\n        
\n                            Exchange a Phrase With One other One within the Earlier Command
\n                    <\/span>
\n       <\/h2>\n
All of us kind quick and mess up generally. Maybe you might be utilizing the fallacious filename, server identify, or have mistyped a flag. As an alternative of retyping the complete command, Bash offers you a fast correction device, the caret (^) image:<\/p>\n
^fallacious^proper<\/pre>\n
This replaces the primary prevalence of “fallacious” in your earlier command with “proper,” and runs the up to date command instantly. Let\u2019s say you meant to ping google.com, however typed ping goggle.com<\/strong> mistakenly. Simply do:<\/p>\n
^goggle^google<\/pre>\n
Bash will run:<\/p>\n
ping google.com<\/pre>\n
\n
\n
\n        \"Replacing<\/p>\n<\/picture>\n<\/figure><\/div>\n<\/p><\/div>\n
This may be helpful when you’ve got a fast typo to repair, and it occurred solely as soon as.<\/p>\n
\n            9 <\/span>
\n        
\n                            Swap the Characters Earlier than and After the Cursor
\n                    <\/span>
\n       <\/h2>\n
For those who’re a quick typist, you’ve got most likely mashed the fallacious keys and typed one thing like:<\/p>\n
sl<\/pre>\n
Once you truly wished to kind:<\/p>\n
ls<\/pre>\n
\n
\n
\n
Sure, that\u2019s such a standard typo that there\u2019s actually a command-line joke tool<\/a> known as sl that exhibits a practice chugging throughout your display screen.<\/p>\n<\/p><\/div>\n<\/p><\/div>\n<\/section>\n
However as a substitute of hitting backspace, retyping, or reaching for the arrow keys, there\u2019s a faster repair. Simply hit Ctrl+T. It swaps the 2 characters proper round your cursor. Let\u2019s say you typed:<\/p>\n
grpe file.txt<\/pre>\n
You meant grep. Simply place the cursor on the p, hit Ctrl+T, and it turns into:<\/p>\n
grep file.txt<\/pre>\n
It\u2019s a tiny trick that feels minor till you catch your self utilizing it 20 instances a day.<\/p>\n
\n            8 <\/span>
\n        
\n                            Utilizing Aliases
\n                    <\/span>
\n       <\/h2>\n
Let\u2019s face it. Some Linux instructions are simply lengthy. And once you’re operating them typically, typing the identical flags or full paths will get irritating. To not point out error-prone. That\u2019s the place aliases<\/a> are available. They can help you create your personal command shortcuts, utilizing easy names for extra advanced or regularly used instructions.<\/p>\n
Creating an alias is so simple as:<\/p>\n
alias shortname=\"precise command right here\"<\/pre>\n
Let\u2019s say you\u2019re at all times operating:<\/p>\n
ls -lah --color=auto<\/pre>\n
You may shortly create an alias like this:<\/p>\n
alias ll=\"ls -lah --color=auto\"<\/pre>\n
\n
\n
\n        \"An<\/p>\n<\/picture>\n<\/figure><\/div>\n<\/p><\/div>\n
Now you’ll be able to simply run ll<\/code> on the terminal to do the entire thing. Notice that this may solely be legitimate for the present terminal session. If you wish to create a everlasting alias, you will have so as to add it to the ~\/.bashrc file and reload it.<\/p>\n
\n            7 <\/span>
\n        
\n                            Format Your Output in Columns
\n                    <\/span>
\n       <\/h2>\n
On Linux, we frequently have to work with information within the command line. Generally, the output could be fairly messy. Fortunately, now we have the column command. It could possibly flip that chaos into clear, readable tables of information. The column command codecs textual content into neat columns, aligning issues properly primarily based on whitespace or a customized delimiter. It is good once you’re coping with information like lists, CSV, colon-separated information, and many others.<\/p>\n
Let’s examine a standard instance. We will usually record the processes on Linux with:<\/p>\n
ps aux<\/pre>\n
We will format it additional utilizing the column command:<\/p>\n
ps aux | head -10 | column -t<\/pre>\n
\n
\n
\n        \"An<\/p>\n<\/picture>\n<\/figure><\/div>\n<\/p><\/div>\n
This tells column to create a desk with aligned columns. When utilizing this command, it is best you probably have predictable enter. In case your information is wildly inconsistent, the output would possibly nonetheless look a bit tough. Furthermore, in case your delimiter seems in values, it’d throw off the formatting.<\/p>\n
\n            6 <\/span>
\n        
\n                            Working A number of Instructions Consecutively
\n                    <\/span>
\n       <\/h2>\n
Generally you wish to run a number of instructions again to again. As an alternative of typing them one after the other and ready, you’ll be able to chain them collectively on a single line. Then, management whether or not they run unconditionally or provided that the earlier one succeeds.<\/p>\n
The semicolon (;) allows you to chain instructions so that they run one after the opposite, no matter success or failure.<\/p>\n
echo \"Updating...\" ; sudo apt replace ; echo \"Performed!\"<\/pre>\n
\n
\n
\n        \"Running<\/p>\n<\/picture>\n<\/figure><\/div>\n<\/p><\/div>\n
 On this instance, even when apt replace<\/strong> fails, the ultimate echo “Performed!”<\/strong> nonetheless runs.<\/p>\n
The && operator, then again, ensures that every command solely runs if the one earlier than it succeeds. This can be a smarter technique to chain instructions.<\/p>\n
sudo apt replace && sudo apt improve<\/pre>\n
The command after && will solely run if the command earlier than it runs efficiently. The alternative of && is the || (two vertical bars) operator. When two instructions are mixed utilizing this image, the command on the correct will execute provided that the command on the left fails. Utilizing && and || helps you debug points along with your Bash scripts<\/a>.<\/p>\n
\n
\t\t<\/p>\n
\n
\n
\n
\n        \"A<\/p>\n<\/picture>\n<\/figure><\/div>\n<\/p><\/div>\n<\/p><\/div>\n
\t\t<\/a><\/p>\n
                    Associated<\/span><\/p>\n
\n
\n
\t\t
\n\t\t\t5 Ways to Make Linux Commands Work the Way You Want
\n\t\t<\/a>
\n\t<\/h5>\n
You do not actually know the complete energy of Linux till you’ll be able to tweak your toolset.<\/p>\n<\/p><\/div>\n<\/p><\/div>\n
\n            5 <\/span>
\n        
\n                            Utilizing Fingerprint As an alternative of a Password
\n                    <\/span>
\n       <\/h2>\n
Typing your password each time you run sudo or unlock your display screen? It is safe, however after doing it a number of instances, it begins feeling tedious. In case your laptop computer has a fingerprint reader, you should use it to authenticate as a substitute of typing your password.<\/p>\n
\n
\n
\n
These steps are geared in the direction of Ubuntu and derivatives. The steps could differ for different distros.<\/p>\n<\/p><\/div>\n<\/p><\/div>\n<\/section>\n
First, set up the required packages:<\/p>\n
sudo apt set up fprintd libpam-fprintd<\/pre>\n
After that, run this command to scan your fingerprint:<\/p>\n
fprintd-enroll<\/pre>\n
Then open the PAM configuration file for sudo:<\/p>\n
sudo nano \/and many others\/pam.d\/sudo<\/pre>\n
Add this line on the prime:<\/p>\n
auth ample pam_fprintd.so<\/pre>\n
\n
\n
\n        \"Adding<\/p>\n<\/picture>\n<\/figure><\/div>\n<\/p><\/div>\n
 Run a command with sudo to check the fingerprint. The system will immediate you to scan your fingerprint as a substitute of asking for a password.<\/p>\n
\n            4 <\/span>
\n        
\n                            Go to the Earlier Listing You Have been In
\n                    <\/span>
\n       <\/h2>\n
I typically discover myself leaping forwards and backwards between two directories. Typing the complete path repeatedly is annoying. So this neat little trick was a lifesaver for me:<\/p>\n
cd -<\/pre>\n
This command sends you to the earlier working listing, identical to a again button in your Linux file system<\/a>. Let\u2019s say you begin in:<\/p>\n
\/residence\/consumer\/tasks\/web site<\/pre>\n
Then you definitely go to “~\/Downloads.” Now, in the event you run the cd –<\/strong> command, you\u2019re immediately again in “\/residence\/consumer\/tasks\/web site.” And in the event you run cd – once more, you return to “~\/Downloads.”<\/p>\n
\n
\n
\n        \"Using<\/p>\n<\/picture>\n<\/figure><\/div>\n<\/p><\/div>\n<\/div>\n