After completing this unit, you should be able to:

• Use the find and locate commands to search for files
• Use the head and tail commands to view specific lines in a file
• Use the type, which, and whereis commands to find commands
• Use the file command to find out the content of a file
• Use the grep command to search text files for patterns
• Use the cut command to list specific columns of a file
• Use the sort command to sort the contents of a file
• Use the join and paste commands to combine files

Search one or more directory structures for files that meet specified criteria. Display the names of matching files or execute commands against those files.

$ find <where> <what> <how>

$ cd /home/tux1
$ find . -name orange
./orange
./color/orange
./shape/orange
./size/orange

The -exec option executes a command on each of the file names found.

$ find . -name 'b*' -exec ls -i {} \;
187787  ./color/blue
187792  ./shape/box
202083  ./size/big

A set of curly brackets ({ }) is a placeholder for each file name. The backslash (\) escapes the following semicolon (;).

The -ok option also causes command execution but on an interactive basis.

$ find  .  -name  o\*  -ok  rm {}  \;
< rm ... ./orange > ? y
< rm ... ./color/orange > ? y
< rm ... ./shape/orange > ? n
< rm ... ./size/orange > ? y

$ find . -perm 777
./size/giant

File matches expr 1 and expr 2:
$ find . -name 's*' -type f -a -size +2\
>-exec ls -i {} \;
187787  ./sample
187792  ./shape/square
202083  ./size/small

File matches expr 1 or expr 2:
$ find . -name circle -o -name 'b*'
./color/blue
./size/big
./shape/box
./shape/circle

To find out what the path to a command is, use type.

$ type find echo
find is /usr/bin/find
echo is a shell builtin

To find out where the binary is located, use which.

$ which find echo
/usr/bin/find
/bin/echo

To locate the binary, source, and manual page files of a command, use whereis.

$ whereis find echo
find: /usr/bin/find /usr/share/man/man1/find.1.gz
echo: /bin/echo /usr/share/man/man1/echo.1.gz

With the file command, you can find out what the type of data is in the file.

$ file /etc/passwd /bin/ls /home/tux1 /tmp/fake.jpg
/etc/passwd:   ASCII text
/bin/ls:       ELF 32-bit LSB executable
/home/tux1:    directory
/tmp/fake.jpg: PDF document, version 1.5

grep: Only displays lines that match a pattern
sed: Allows string substitutions
awk: Pattern scanning and processing
fmt: Insert line wraps so that text looks pretty
expand, unexpand: Change tabs to spaces and vice versa
tr: Substitute characters
nl: Number lines
pr: Format for printer    
tee: reads standard input and sends the data to both 
     standard output and a file
sort: Sort the lines in the fil
cut: list specific columns of a file
head and tail  : view specific lines in a file
join and paste : combine files
tac: Display lines in reverse order
rev: reverse the order of characters in every line

Searches one or more files or standard input for lines matching a pattern Simple match or regular expression.

grep  [options]  pattern  [file1 ...]

-v      Print lines that do not match
-c      Print only a count of matching lines
-l      Print only the names of files with matching lines
-n      Number the matching lines
-i      Ignore case of letters when making comparisons
-w      Do a whole word search
-f <file>   Read expressions from file instead command line

Phone1:

Chris                   10300       internal
Jan                     20500       internal
Lee                     30500       external
Pat                     40599       external
Robin                   50599       external
Terry                   60300       internal

Phone2:

Chris                   1342        internal
Jan                     2083        internal
Lee                     3139        external
Pat                     4200        internal
Robin                   5200        internal
Terry                   6342        external

$ grep 20 phone1
Jan     20500       internal

$ grep 20 phone*
phone1:Jan      20500       internal
phone2:Jan      2083        internal    
phone2:Pat      4200        internal
phone2:Robin    5200        internal

$ grep -v Jan phone2
Chris       1342        internal
Lee         3139        external
Pat         4200        internal
Robin       5200        internal
Terry       6342        external

Patterns with metacharacters should be in single quotation marks (') so that the shell will leave it alone. Valid metacharacters with grep include $ . * ^ [ - ].

Match a single character:

.       Any single character
[a-f]   Any one of the characters in the range a through f
[^a-f]  Any one of the characters not in the range a through f

Example:

$ grep '[1-3].[^3-5]' phone1
Chris                   10300       internal
Terry                   60300       internal

Backslash is used for sepial metacharacters

\.  \[  \]  \\   
\t  : tab  
\d  : any digit, equals [0-9]  
\D  : not \d, equals [^0-9]  
\w  : any letter or digit or underscore, equals [a-zA-Z0-9_]
\W  : not \w, equals [^a-zA-Z0-9_]

A regular expression may be followed by one of several repetition operators:

   ?      The preceding item is optional and matched at most once.
   *      The preceding item will be matched zero or more times.
   +      The preceding item will be matched one or more times.
   {n}    The preceding item is matched exactly n times.
   {n,}   The preceding item is matched n or more times.
   {,m}   The preceding item is matched at most m times.  This  is  a  GNU
          extension.
   {n,m}  The  preceding  item  is  matched at least n times, but not more
          than m times.

^a      Any line that starts with a
z$      Any line that ends with z
\b      boundary of the word. (that is, between \w and \W)

Example:

Display only the lines of phone1 that contain an e and end in a 0:  
$ grep ___________ phone1

fgrep allows only fixed strings (no regular expressions). egrep allows for multiple (alternate) patterns.

$ egrep '20500|40599|50599' phone1
Jan         20500   internal
Pat         40599   external
Robin       50599   external

What does the following command do?

$ grep 30 phone1 | grep intern
????????

Pull selected columns or fields from one or more files
Syntax:

cut -f(ields) -d(elimiter) file(s)
cut -c(haracters) file(s)

Example:

$ cat /etc/passwd
root:x:0:0:Big Brother:/root:/bin/bash
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
tux1:x:500:500:Tux the Penguin(1):/home/tux1:/bin/bash
tux2:x:501:501:Tux the Penguin(2):/home/tux2:/bin/bash

$ cut -f1,3,6,7 -d: /etc/passwd
root:0:/root:/bin/bash
shutdown:6:/sbin:/sbin/shutdown
tux1:500:/home/tux1:/bin/bash
tux2:501:/home/tux2:/bin/bash

$ ps
  PID TTY STAT TIME COMMAND
 9374 p0  S    0:00 -bash
14460 p0  R    0:00 ps

$ ps | cut -c-5,20-
  PID COMMAND
 9374 -bash
14471 ps

The sort command sorts the lines in the file specified and writes the result to standard output.

sort -tdelimiter -kfield -options file

$ cat animals
dog.2
cat.4
penguin.10

$ sort animals
cat.4
dog.2
penguin.10

$ sort -k1.2 animals
cat.4
penguin.10
dog.2
$ sort -t. -k2 animals
penguin.10
dog.2
cat.4
$ sort -t. -n -k2 animals
dog.2
cat.4
penguin.10

Options

-d  Sorts in dictionary order (only letters, digits, spaces)
-r  Reverses the order of the specified sort
-n  Sorts numeric fields in arithmetic value

The head command can be used to view the first few lines of a file or files. The command syntax is:

$ head  [-lines] file(s)

$ head -5 myfile
$ ls -l | head -12

The head command shows you the first ten lines of a file by default.

The tail command displays the last few lines of a file or files. The command syntax is:

$ tail [{-lines|-n lines|-n +lines|-f}] file(s)
$ tail -20 file
$ tail -n +20 file
$ tail -f file

-n Indicates the number of lines to read beginning from the end of the file. This displays the last n lines of the file.
+n Indicates the number of the line where you want to start displaying the lines.
The -f option causes the tail command to continue to read additional lines from the input file as they become available. For example: tail -f logfile

Question: How to show middle 10 lines of a 30-line file?

The join and paste commands combine files.

$ cat one
a apple another
b bee beast
c cat

$ cat two
a ape
b broken
d dog

$ join one two
a apple another ape
b bee beast broken

$ paste one two
a apple another a ape
b bee beast     b broken
c cat   d dog

Having completed this unit, you should be able to:

• Use the find and locate commands to search for files
• Use the type, which, and whereis commands to find commands
• Use the file command to find out the content of a file
• Use the grep command to search text files for patterns
• Use the cut command to list specific columns of a file
• Use the sort command to sort the contents of a file
• Use the head and tail commands to view specific lines in a file
• Use the join and paste commands to combine files

• Unit 10: Linux utilities, Linux Basics and Installation , ERC 7.2, IBM