Lecture 6

More gawking and other useful tricks

For this lecture, consider the same student.grades file as previous lecture. Here are some gawk scripts to:
- Read each record (line) and break it up into multiple records. Notice the use of NF to specify the number of fields. Also, observe the difference between print and printf. The latter is just like the C-language construct. The former appends newlines after whatever it prints, which can be undesirable sometimes.
```
{
   for (i=1; i <= NF; i++) 
   {
      print $i
   }
   printf "\n"
}
```
- Take the output of the previous gawk and 'restitch' the lines back to what they were. Notice that now we have to contend with multi-line records. We first define the field separator (FS) to be the newline and the record separator (RS) to be a blank. This over-rides the defaults of white space for FS and newline for RS. For each record read, we print back the fields but now in tab-delimited format, and then put a newline at the end of each record (observe however that there will be an extra tab at the end of each line due to how we have written the for loop).
```
BEGIN {
    FS = "\n"
    RS = ""
}

{
    for (i=1; i<=NF; i++) {
      	printf "%s\t", $i
    }
	
    printf "\n"
}
```
- Note that $NF is also a variable. Try to print its value print $NF to see what happens. What does it equal to after each line is processed?
- Perform substitutions.
```
{

{gsub(/John/, "Jon Smith")}


print

}

		 Search for patterns. Note the  ~  for matching 
	a field, and that your pattern must be inside  /  /   

{


if ( /J/ || $5 ~/9/ ) print

}
```
  INPUT:
  John 45 55 60 90
  Mary 70 75 88 100
  Jimmy 75 80 85 100
  Kathy 80 70 70 95
  
  OUTPUT:
  John 45 55 60 90
  Jimmy 75 80 85 100
  Kathy 80 70 70 95

Sorting with gawk

Consider the input file silly containing the following five lines:
```
2 is an even prime number.
3 is a crowd.
1 is next to a prime.
5 is first odd number after 4.
4 is just added here for completeness sake.
```
Let us suppose we want to sort the lines so that the line about number 1 is first, then the line about number 2, and so on. Here's a gawk script for this purpose:
```
{
   store[$1] = $0
}
END {
   for (i=1; i<=NR; i++)
     print store[i]
}
```
Here we are using an associative array store to store each line (in $0) alongside an index (which is the first field, or $1). At the end of the day, we print all lines in sorted order by going through the array store linearly. NR is the number of records read thus far.

Try the above awk scripts on your own. The easiest thing to do is to open a file using vim, say try.awk , then switch to the insert mode (esc i), and copy and paste any of the above scripts into the file. Depending on your machine's set up, pasting is done by clicking the middle button of your mouse, or right and left at the same time. ctrl p may also work. Do not forget to add the following line on top: #!/usr/bin/gawk -f Also, do chmod +x try.awk

sort: a better sort

UNIX sort is a very powerful command, for instance:

sort silly gets the same effect as the above gawk script!
The command
```
sort  <filename>
```
sorts <filename> by default according to field 1. Default sorting is ascending order of character. If you want a numeric sort, append n after the field numbers, e.g., sort -n <filename>.
Suppose you have silly that looks like:
```
number 2 is an even prime number.
number 3 is a crowd.
number 1 is next to a prime.
number 5 is first odd number after 4.
number 4 is just added here for completeness sake.
	
```
And you want the file sorted the same way as before. You can do sort -n -k 2 <filename>. Note that -k 2 tells sort to use the second field for sorting. Now try sort -n -r -k 2 <filename>. What happens?
Do a man sort to learn about more options!

find: searching for files

UNIX find is a powerful utility to search for files (i.e., names of files, not file contents, which is what you use egrep for).

find . recursively searches through the current directory (the "." part) and lists the names of all files it encounters. If you run this command at a top-level of a directory tree, you will be bombarded with output!
find . -name "*CS2204*" recursively searches through the current directory and finds those files whose names contain "CS2204".
Do a man find to get more options!
Another search program locate is even faster then find above! But it is not as general + relies on a pre-built database (which is periodically updated). Takes a long time the very first time, then goes very fast.
There is also which but this one only finds executables, and only searches amonth thge directories specified in the path variable of your UNIX shell.