Linux / UNIX command examples
(hopefully useful! Warning: I am a biologist!)
Vienna meeting poster session
22 / 10 / 2013
Vedran Bozicevic
Contents
1. Tar command tutorial with 10 practical examples
2. Get a grip on the grep!
3. Mommy, I found it! The Linux find command
4. Advanced sed substitution examples
5. Some powerful awk built-in variables: FS, OFS, RS, ORS, NR, NF, FILENAME, FNR
6. How to record and play in the Vim editor
7. Unix ls command
8. Awesome cd command hacks
9. Unix less command – tips for effective navigation
A short tar command tutorial
$ tar cvzf archive_name.tar.gz dirname/ – create a new (-c) tar gzipped (-z) archive verbosely (-v) with the following (-f) filename
$ tar cvfj archive_name.tar.bz2 dirname/ – do the same, only filter the archive through bzip2 instead – takes more time, but has better
compression
$ tar xvf archive_name.tar – extract (-x) file from archive; add -z for .gz or -j for .bz2
$ tar tvf archive_name.tar – view the archive content without extracting; add same for .gz, .bz2
$ tar xvf archive_file.tar /path/to/file – extract only a specific file from a large archive
$ tar xvf archive_file.tar /path/to/dir/ - extract a specific directory
$ tar xvf archive_file.tar /path/to/dir1/ /path/to/dir2/ - extract multiple directories
$ tar xvf archive_file.tar --wildcards '*.pl' – extract a group of files using regular expression
$ tar rvf archive_name.tar newfile – add an additional file to an existing tar archive
$ tar -cf - /directory/to/archive/ | wc -c – estimate the tar file size in KB before creating it
Get a grip on the grep!
First create the following demo_file to be used in examples below for demonstration purposes:
$ cat demo_file
THIS LINE IS THE 1ST UPPER CASE LINE IN THIS FILE.
this line is the 1st lower case line in this file.
This Line Has All Its First Character Of The Word With Upper Case.
Two lines above this line is empty.
And this is the last line.
Basic usage: search for lines containing a specific string:
$ grep "this" demo_file
this line is the 1st lower case line in this file.
Two lines above this line is empty.
Get a grip on the grep!
Copy the demo_file to demo_file1. Check for the given string in both using a pattern:
$ cp demo_file demo_file1
$ grep "this" demo_*
demo_file:this line is the 1st lower case line in this file.
demo_file:Two lines above this line is empty.
demo_file:And this is the last line.
demo_file1:this line is the 1st lower case line in this file.
demo_file1:Two lines above this line is empty.
demo_file1:And this is the last line.
Do a case-insensitive (-i) search:
$ grep -i "the" demo_file
THIS LINE IS THE 1ST UPPER CASE LINE IN THIS FILE.
this line is the 1st lower case line in this file.
This Line Has All Its First Character Of The Word With Upper Case.
And this is the last line.
Get a grip on the grep!
Match a regular expression in files:
$ grep "lines.*empty" demo_file
Two lines above this line is empty.
Check for full words, not for sub-strings (“is” in “This” will NOT match):
$ grep -iw "is" demo_file
THIS LINE IS THE 1ST UPPER CASE LINE IN THIS FILE.
this line is the 1st lower case line in this file.
Two lines above this line is empty.
And this is the last line.
Highlight the search using GREP_OPTIONS:
$ export GREP_OPTIONS='--color=auto' GREP_COLOR='100;8'
$ grep this demo_file
this line is the 1st lower case line in this file.
Two lines above this line is empty.
And this is the last line.
Get a grip on the grep!
Search for the string “vedran” within all files under the current directory and all of its sub-directories recursively:
$ grep -r "vedran" *
Display the lines that do not contain a given string / pattern:
$ grep -v "file" demo_file
This Line Has All Its First Character Of The Word With Upper Case.
Two lines above this line is empty.
And this is the last line.
The same, only for multiple patterns:
$ cat test-file.txt
a
b
c
d
$ grep -v -e "a" -e "b" -e "c" test-file.txt
d
Get a grip on the grep!
Count how many lines do NOT match the given pattern / string:
$ grep -v -c "file" demo_file1
3
Use a regular expression as a pattern, but show only the matched string, and not the entire line:
$ grep -o "is.*line" demo_file
is line is the 1st lower case line
is line
is is the last line
Show the position where grep matched the pattern in the file:
$ cat temp-file.txt
12345
12345
$ grep -o -b "3" temp-file.txt
2:3
8:3
Mommy, I found it! The Linux find
command
Same as before, let's create some sample files to use the find command examples on:
$ vim create_sample_files.sh
touch MybashProgram.sh
touch mycprogram.c
touch MyCProgram.c
touch Program.c
mkdir backup
cd backup
touch MybashProgram.sh
touch mycprogram.c
touch MyCProgram.c
touch Program.c
$ chmod +x create_sample_files.sh
$ ./create_sample_files.sh
$ ls -R
.:
backup
MybashProgram.sh MyCProgram.c
Mommy, I found it! The Linux find
command
The basic usage: find all files with (-name) “MyCProgram.c”, ignoring (-i) the case in the current dir and all of its
sub-dirs:
$ find -iname "MyCProgram.c"
./mycprogram.c
./backup/mycprogram.c
./backup/MyCProgram.c
./MyCProgram.c
Limit the search to particular directory levels using the options -mindepth and -maxdepth; for instance, find the
“passwd” file under root and two levels down, i.e. root = level 1, and two sub-dirs = level 2 and 3:
$ find / -maxdepth 3 -name passwd
./usr/bin/passwd
./etc/pam.d/passwd
./etc/passwd
Mommy, I found it! The Linux find
command
Or, find the password file between sub-dir levels 2 and 4:
$ find -mindepth 3 -maxdepth 5 -name passwd
./usr/bin/passwd
./etc/pam.d/passwd
Invert the match in the following way; the following will show all the files and dirs that do not match the name
“MyCProgram.c” to the depth of 1 (i.e. current dir):
$ find -maxdepth 1 -not -iname "MyCProgram.c"
.
./MybashProgram.sh
./create_sample_files.sh
./backup
./Program.c
Mommy, I found it! The Linux find
command
Execute commands on the files found using -exec, e.g. let's calculate the md5sums of all the files with the name
MyCProgram.c, ignoring case. {} is replaced by the current file name:
$ find -iname "MyCProgram.c" -exec md5sum {} \;
d41d8cd98f00b204e9800998ecf8427e ./mycprogram.c
d41d8cd98f00b204e9800998ecf8427e ./backup/mycprogram.c
d41d8cd98f00b204e9800998ecf8427e ./backup/MyCProgram.c
d41d8cd98f00b204e9800998ecf8427e ./MyCProgram.c
Find the top 5 big files or the top 5 small files:
$ find . -type f -exec ls -s {} \; | sort -n -r | head -5
$ find . -type f -exec ls -s {} \; | sort -n | head -5
Or files bigger than or smaller than the given size:
$ find ~ -size +100M
$ find ~ -size -100M
Find all (“.*”) non-hidden (-not) zero-byte (-empty) files in only the current directory (-maxdepth 1):
$ find . -maxdepth 1 -empty -not -name ".*"
Mommy, I found it! The Linux find
command
Use the option -type to find e.g. all the hidden (-type f) files:
$ find . -type f -name ".*"
Or all the hidden directories (-type d):
$ find -type d -name ".*"
Or only the normal (-type f) files:
$ find . -type f
Slightly more useful: find all the files created or modified after the file “ordinary_file”:
$ ls -lrt
total 0
-rw-r----- 1 root root 0 2009-02-19 20:27 others_can_also_read
----r----- 1 root root 0 2009-02-19 20:27 others_can_only_read
-rw------- 1 root root 0 2009-02-19 20:29 ordinary_file
-rw-r--r-- 1 root root 0 2009-02-19 20:30 everybody_read
-rwxrwxrwx 1 root root 0 2009-02-19 20:31 all_for_all
$ find -newer ordinary_file
Mommy, I found it! The Linux find
command
You can also create an alias for frequent find operations. For instance, let's create a command called “rmao” to
remove the files named “a.out”:
$ alias rmao="find . -iname a.out -exec rm {} \;"
$ rmao
Another example: remove the “core” files (“rmc”) generated by a C program:
$ alias rmc="find . -iname core -exec rm {} \;"
$ rmc
Remove all “.zip” files bigger than 100 MB:
$ find / -type f -name *.zip -size +100M -exec rm -i {} \;"
Put together, let's remove all “.tar” files over 100 MB, creating alias “rm100m”:
$ alias rm100m="find / -type f -name *.tar -size +100M -exec rm -i {} \;"
$ rm100m
Or, similarly, remove all the “.zip” files over 2 GB with the alias “rm2g”:
$ alias rm2g=”find / -type f -name *.zip -size +2G -exec rm -i {} \;”
$ rm1g
Mommy, I found it! The Linux find
command
You can also create an alias for frequent find operations. For instance, let's create a command called “rmao” to
remove the files named “a.out”:
$ alias rmao="find . -iname a.out -exec rm {} \;"
$ rmao
Another example: remove the “core” files (“rmc”) generated by a C program:
$ alias rmc="find . -iname core -exec rm {} \;"
$ rmc
Remove all “.zip” files bigger than 100 MB:
$ find / -type f -name *.zip -size +100M -exec rm -i {} \;"
Put together, let's remove all “.tar” files over 100 MB, creating alias “rm100m”:
$ alias rm100m="find / -type f -name *.tar -size +100M -exec rm -i {} \;"
$ rm100m
Or, similarly, remove all the “.zip” files over 2 GB with the alias “rm2g”:
$ alias rm2g=”find / -type f -name *.zip -size +2G -exec rm -i {} \;”
$ rm1g
Advanced sed substitution
examples
Again, let us create an example file first:
$ cat path.txt
/usr/kbos/bin:/usr/local/bin:/usr/jbin:/usr/bin:/usr/sas/bin
/usr/local/sbin:/sbin:/bin/:/usr/sbin:/usr/bin:/opt/omni/bin:
/opt/omni/lbin:/opt/omni/sbin:/root/bin
People typically use sed for substitutions involving regular expressions, e.g. to substitute path names. However, since path names
contain a lot of slashes, and slash is a special character in sed (it delimits a regex), all of them have to be “escaped” using
backslashes. This can result in a “picket-fence”-like pattern (/\/\/\) that can be hard to read, for instance:
$ sed 's/\/opt\/omni\/lbin/\/opt\/tools\/bin/g' path.txt
Luckily, chars such as “@”, “%”, “|”, “:” and “;” can also be used as delimiters:
$ sed 's@/opt/omni/lbin@/opt/tools/bin@g' path.txt
/usr/kbos/bin:/usr/local/bin:/usr/jbin/:/usr/bin:/usr/sas/bin
/usr/local/sbin:/sbin:/bin/:/usr/sbin:/usr/bin:/opt/omni/bin:
/opt/tools/bin:/opt/omni/sbin:/root/bin
Advanced sed substitution
examples
Grouping can also be used with sed; a group is opened using “(“ and closed using “)”. In the newer versions of sed one doesn't have to
escape the parentheses. Grouping can be used in combination with back-referencing. This will re-use a part of the regex that was
selected by grouping. For example, the following will change the order of the field in the last line of the file “path.txt”:
$ sed '$s@([^:]*):([^:]*):([^:]*)@\3:\2:\1@g' path.txt
Here, “$” specifies substitution to happen only for the last line, and “@” are the delimiters. The output shows that the order of the path
values in the last line has been reversed:
/usr/kbos/bin:/usr/local/bin:/usr/jbin:/usr/bin:/usr/sas/bin
/usr/local/sbin:/sbin:/bin:/usr/sbin:/usr/bin:/opt/omni/bin:
/root/bin:/opt/omni/sbin:/opt/omni/lbin
This example displays only the first field from the /etc/passwd file:
$sed 's/\([^:]*\).*/\1/' /etc/passwd
root
bin
daemon
adm
lp
Advanced sed substitution
examples
For the following file:
$ cat numbers
1234
12121
3434
123
This expression will insert commas into the numbers, to separate out the thousands from the rest:
$ sed 's/\(^\|[^0-9.]\)\([0-9]\+\)\([0-9]\{3\}\)/\1\2,\3/g' numbers
1,234
12,121
3,434
123
The following example prints the first character of every word in parentheses:
$ echo "Welcome To The Geek Stuff" | sed 's/\(\b[A-Z]\)/\(\1\)/g'
(W)elcome (T)o (T)he (G)eek (S)tuff
Some powerful awk built-in
variables
There are two types of built-in variables in awk, (1) those that define values which can be changed, such as field separators and record
separators, and (2) those which can be used for processing and reports, such as the number of records / the number of fields.
Awk reads and parses each line from input (by default, separated by whitespace), and sets each field to the variables $1, $2, $3 etc.
Awk FS is any single character or regex which you wanna use as an input field separator instead of the default whitespace. It can be
changed any number of times and retains its values until it's explicitly changed.
Here is an awk FS example to read the /etc/passwd file which has “:” as a field delimiter:
$ cat etc_passwd.awk
BEGIN{
FS=":";
print "Name\tUserID\tGroupID\tHomeDirectory";
}
{
print $1"\t"$3"\t"$4"\t"$6;
}
END {
print NR,"Records Processed";
}
Some powerful awk built-in
variables
If we run the script (-f for execute):
$awk -f etc_passwd.awk /etc/passwd
...the output should look like this:
Name
UserID GroupID
HomeDirectory
gnats 41
41
/var/lib/gnats
libuuid 100
101
/var/lib/libuuid
syslog 101
102
/home/syslog
hplip 103
7
/var/run/hplip
avahi 105
111
/var/run/avahi-daemon
saned 110
116
/home/saned
pulse 111
117
/var/run/pulse
gdm 112
119
/var/lib/gdm
8 Records Processed
Some powerful awk built-in
variables
Awk OFS is an output equivalent of FS. By default, awk OFS is a single space character.
The concatenator in the print statement (“,”) concatenates two parameters with a space, which is the value of awk OFS by default. So,
if in the input the numbers on each line are separated by space, the awk OFS value (here, “=”) will be inserted between fields in
the output instead:
$ awk -F':' 'BEGIN{OFS="=";} {print $3,$4;}' /etc/passwd
41=41
100=101
101=102
103=7
105=111
110=116
111=117
112=119
Some powerful awk built-in
variables
Awk RS defines a line. Recall that by default awk reads line-by-line. As an example, let's take students' marks stored in a file, where
each record is separated by a double new line, and each field is separated by a newline character:
$cat student.txt
Jones
2143
78
84
Gondrol
2321
56
58
RinRao
2122
38
37
Some powerful awk built-in
variables
Now the below Awk script prints the student name and Rollno from the above input file:
$cat student.awk
BEGIN {
RS="\n\n";
FS="\n";
}
{
print $1,$2;
}
$ awk -f student.awk student.txt
Jones 2143
Gondrol 2321
RinRao 2122
Some powerful awk built-in
variables
Awk ORS is an Output equivalent of RS. Each record in the output will be printed with this delimiter. In the following script, each record
in the student-marks file is delimited by the character “=”:
$ awk 'BEGIN{ORS="=";} {print;}' student-marks
Jones 2143 78 84 77=Gondrol 2321 56 58 45=RinRao 2122 38 37 65=
Awk NR gives you the total number of records being processed or line number. In the following awk NR example, NR variable has line
number, in the END section awk NR tells you the total number of records in a file.
$ awk '{print "Processing Record - ",NR;}END {print NR, "Students Records are processed";}' student-marks
Processing Record - 1
Processing Record - 2
Processing Record - 3
Processing Record - 4
Processing Record - 5
5 Students Records are processed
Some powerful awk built-in
variables
Awk NF gives you the total number of fields in a record. It'll be very useful for validating whether all the fields exist in a record. In the
following student-marks file, Test3 score is missing for 2 students, RinRao and Dayan:
$cat student-marks
Jones 2143 78 84 77
Gondrol 2321 56 58 45
RinRao 2122 38 37
Edwin 2537 78 67 45
Dayan 2415 30 47
The following awk script prints the record (line) number, and the number of fields in that record. Therefore, it will be very simple to find
out if the Test3 score is missing:
$ awk '{print NR,"->",NF}' student-marks
1 -> 5
2 -> 5
3 -> 4
4 -> 5
5 -> 4
Some powerful awk built-in
variables
When awk reads from a multiple input file, the NR variable will give the total number of records relative to all the input files. Awk FNR
will give the number of records for each input file:
$ awk '{print FILENAME, FNR;}' student-marks bookdetails
student-marks 1
student-marks 2
student-marks 3
student-marks 4
student-marks 5
bookdetails 1
bookdetails 2
bookdetails 3
bookdetails 4
Bookdetails 5
Here, if we had used NR instead (for the file bookdetails), we would instead get between 6 and 10 for each record.
Some powerful awk built-in
variables
The FILENAME variable gives the name of the file being read. In this example, it prints the FILENAME, i.e. student-marks, for each
record of the input file:
$ awk '{print FILENAME}' student-marks
student-marks
student-marks
student-marks
student-marks
student-marks
How to record and play in Vim editor
Using the Vim Macro feature you can record and play a sequence of actions inside the editor.For example, you can generate a
sequence of numbers.
First, start a sequence-test.txt file to generate the sequence:
$ vim sequence-test.txt
Next, go to insert mode and type “1 .”; type: Esc i followed by 1.:
$ vim sequence-test.txt
1.
Now type “Esc q” followed by “a”. Here, “q” starts the recording, and “a” stores the recording in the register “a”. At the bottom of the
screen, vim will display the message “recording”.
Next, type “Esc yy” followed by “p”. The “yy” (short for “yank”) will copy the current line, and “p” will paste it.
$ vim sequence-test.txt
1.
1.
Now, increment the number by placing the cursor at the 2nd line, and typing “Ctrl a”.
$ vim sequence-test.txt
1.
2.
How to record and play in Vim editor
Press “q” to stop the recording. You’ll notice that the recording message at the bottom of the vim editor is now gone.
Type “98 @ a” now. This will repeat the stored macro “a” 98 times. This will generate a sequence of numbers from 1. to 100.
The mighty UNIX ls command
Unix users and sysadmins cannot live without this two letter command. Whether you use it 10 or 100 times a day, knowing the power
of the ls command can make your command line journey much more enjoyable.
For instance, if it had been the following two text files that we were editing before:
$ vi first-long-file.txt
$ vi second-long-file.txt
Then the following will open the last file we edited (i.e “second-long-file.txt”)
$ vi `ls -t | head -1`
To show a single entry per line, use the “-1” option:
$ ls -1
bin
boot
cdrom
dev
etc
home
initrd
initrd.img
The mighty UNIX ls command
The ls -l command will show long listing information about a file/directory. Use ls -lh (“h” stands for “human readable” form) to display
the file size in an easy-to-read format, i.e M for MB, K for KB, G for GB:
$ ls -l
-rw-r----- 1 ramesh team-dev 9275204 Jun 12 15:27 arch-linux.txt.gz*
$ ls -lh
-rw-r----- 1 ramesh team-dev 8.9M Jun 12 15:27 arch-linux.txt.gz
If you want the directory details, you can use the “-ld” option:
$ ls -ld /etc
drwxr-xr-x 21 root root 4096 Jun 15 07:02 /etc
And if you want to order the files based on last time modified, use “-lt”:
$ ls -lt
total 76
drwxrwxrwt 14 root root 4096 Jun 22 07:36 tmp
drwxr-xr-x 121 root root 4096 Jun 22 07:05 etc
drwxr-xr-x 13 root root 13780 Jun 22 07:04 dev
drwxr-xr-x 13 root root 4096 Jun 20 23:12 root
drwxr-xr-x 12 root root 4096 Jun 18 08:31 home
The mighty UNIX ls command
The “-ltr” option will order the files in reverse order of last time modified:
$ ls -ltr
total 76
drwxr-xr-x 15 root root 4096 Jul 2 2008 var
drwx------ 2 root root 16384 May 17 20:29 lost+found
lrwxrwxrwx 1 root root
11 May 17 20:29 cdrom -> media/cdrom
drwxr-xr-x 2 root root 4096 May 17 21:21 sbin
drwxr-xr-x 12 root root 4096 Jun 18 08:31 home
To show all the hidden files in the directory, use ‘-a option’. Hidden files in Unix starts with ‘.’ in its file name:
$ ls -a
[rnatarajan@asp-dev ~]$ ls -a
.
Debian-Info.txt
..
CentOS-Info.txt
.bash_history
Fedora-Info.txt
.bash_logout
.lftp
.bash_profile
libiconv-1.11.tar.tar
The mighty UNIX ls command
To show all the files recursively, use the “-R” option. When you do this from /, it shows all the unhidden files in the whole file system
recursively:
$ ls /etc/sysconfig/networking
devices profiles
/etc/sysconfig/networking/devices:
/etc/sysconfig/networking/profiles:
default
/etc/sysconfig/networking/profiles/default:
Instead of doing the ‘ls -l’ and then checking for the first character to determine the type of file, you can use -F which classifies the file
with different special character for different kind of files:
$ ls -F
Desktop/ Documents/ Ubuntu-App@ firstfile Music/ Public/ Templates/
In the above, “/” is a directory, “@” is a link file, and “*” is an executable file.
The mighty UNIX ls command
Recognizing the file type by the color in which it gets displayed is another possible kind of file classification. Here the directories get
displayed in blue, soft links get displayed in green, and ordinary files gets displayed in the default color:
$ ls --color=auto
Desktop Documents Examples firstfile Music Pictures Public Templates Videos
You can take some required ls options in the above, and make aliases for easier use, e.g. the following:
Long list the file with size in human understandable form.
$ alias ll="ls -lh"
Classify the file type by appending special characters.
$ alias lv="ls -F"
Classify the file type by both color and special character.
$ alias ls="ls -F --color=auto"
Some awesome cd command hacks
Hack #1: Use CDPATH to define the base directory for cd command
If you are frequently doing cd to subdirectories of a specific parent directory, you can set the CDPATH to the parent directory and
perform cd to the subdirectories without giving the parent directory path:
[ramesh@dev-db ~]$ pwd
/home/ramesh
[ramesh@dev-db ~]$ cd mail
-bash: cd: mail: No such file or directory
[Note: This is looking for mail directory under current directory]
[ramesh@dev-db ~]$ export CDPATH=/etc
[ramesh@dev-db ~]$ cd mail
[Note: This is looking for mail under /etc and not under current directory]
[ramesh@dev-db /etc/mail]$ pwd
/etc/mail
Some awesome cd command hacks
Hack #2: Use cd alias to navigate up the directory effectively
When you are navigating up a very long directory structure, you may be using cd ..\..\ with multiple ..\ depending on how many
directories you want to go up. Instead of executing cd ../../../.. to navigate four levels up, use aliases:
alias ..="cd .."
alias ..2="cd ../.."
alias ..3="cd ../../.."
alias ..4="cd ../../../.."
alias ..5="cd ../../../../.."
$ cd /tmp/very/long/directory/structure/that/is/too/deep
$..4
[Note: use ..4 to go up 4 directory level]
$ pwd
/tmp/very/long/directory/structure/
Some awesome cd command hacks
Hack #3: Perform mkdir and cd using a single command
Sometimes when you create a new directory, you may cd to the new directory immediately to perform some work as shown below.
$ mkdir -p /tmp/subdir1/subdir2/subdir3
$ cd /tmp/subdir1/subdir2/subdir3
$ pwd
/tmp/subdir1/subdir2/subdir3
Wouldn’t it be nice to combine both mkdir and cd in a single command? Add the following to the .bash_profile and re-login.
$ function mkdircd () { mkdir -p "$@" && eval cd "\"\$$#\""; }
Now, perform both mkdir and cd at the same time using a single command as shown below:
$ mkdircd /tmp/subdir1/subdir2/subdir3
[Note: This creates the directory and cds to it automatically]
$ pwd
/tmp/subdir1/subdir2/subdir3
Some awesome cd command hacks
Hack #4: Use “cd -” to toggle between the last two directories
You can toggle between the last two current directories using “cd –“:
$ cd /tmp/very/long/directory/structure/that/is/too/deep
$ cd /tmp/subdir1/subdir2/subdir3
$ cd $ pwd
/tmp/very/long/directory/structure/that/is/too/deep
$ cd $ pwd
/tmp/subdir1/subdir2/subdir3
$ cd $ pwd
/tmp/very/long/directory/structure/that/is/too/deep
Some awesome cd command hacks
Hack #5: Use “shopt -s cdspell” to automatically correct mistyped directory names on cd
Use shopt -s cdspell to correct the typos in the cd command automatically as shown below. If you are not good at typing and make lot
of mistakes, this will be very helpful:
$ cd /etc/mall
-bash: cd: /etc/mall: No such file or directory
$ shopt -s cdspell
$ cd /etc/mall
$ pwd
/etc/mail
[Note: By mistake, when I typed mall instead of mail,
cd corrected it automatically]
UNIX less command – tips for
effective navigation
I personally prefer to use the “less” command to view files (instead of opening the file to view in an editor). Less is similar to “more”, but
it allows both forward and backward movements. Moreover, less doesn't require loading the whole file before viewing. Try opening
a large log file in Vim editor and less — you’ll see the speed difference.
The navigation keys in less are similar to the Vim editor. These few less command navigation and other operations will make you a
better command line warrior:
Forward Search
/ – search for a pattern which will take you to the next occurrence.
n – for next match in forward
N – for previous match in backward
Backward Search
? – search for a pattern which will take you to the previous occurrence.
n – for next match in backward direction
N – for previous match in forward direction
Tip: If you don't care about which direction the search is happening, and you want to look for a file path, or URL, such as
“/home/ramesh/”, you can use the backward search (?pattern) which will be handy as you don’t want to escape slashes each
time.
Search Path
In forward: /\/home\/ramesh\/
In backward: ?/home/ramesh/
UNIX less command – tips for
effective navigation
Use the following screen navigation commands while viewing large log files.
CTRL+F – forward one window
CTRL+B – backward one window
CTRL+D – forward half window
CTRL+U – backward half window
In a smaller chunk of data, where you want to locate a particular error, you may want to navigate line by line using these keys:
j – navigate forward by one line
k – navigate backward by one line
The following are other navigation operations that you can use inside the less pager.
G – go to the end of file
g – go to the start of file
q or ZZ – exit the less pager
UNIX less command – tips for
effective navigation
Once you’ve opened a file using the less command, any content that is appended to the file after that will not be displayed
automatically. However, you can press F to show the status ‘waiting for data‘. This is similar to ‘tail -f’.
Similarly to the Vim editor navigation command, you can enter 10j to scroll 10 lines down, or 10k to go up by 10 lines. Ctrl-G will show
the current file name along with line, byte and percentage statistics.
Other useful Less Command Operations
v – using the configured editor edit the current file.
h – summary of less commands
&pattern – display only the matching lines, not all.
When you are viewing a large log file using less command, you can mark a particular position and return back to that place again by
using that mark.
ma – mark the current position with the letter ‘a’,
‘a – go to the marked position ‘a’.
UNIX less command – tips for
effective navigation
Less Command – Multiple file paging
Method 1: You can open multiple files by passing the file names as arguments.
$ less file1 file2
Method 2: While you are viewing file1, use :e to open the file2 as shown below.
$ less file1
:e file2
Navigation across files: When you opened more than two files ( for e.g – less * ), use the following keys to navigate between files.
:n – go to the next file.
:p – go to the previous file.