Oct 17

More gawking

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"
}
```
- Flip alternate lines. This provides the equivalent functionality of the corresponding sed script we saw a couple of weeks ago.
```
{
    oldline = $0
    if ((getline) == 1) {
        print $0
        print oldline
    } else {
        print oldline
    }
}
```

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.

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 +0 -1 +2 <filename>
```
sorts <filename> first according to field 1 (unlike gawk, sort organizes fields from count zero), then within records that have the same value for field 1, it sorts according to the third field (the +2 part above). The -1 part instructs sort to ignore the second field. Typical sorting is ascending order of character. If you want a numeric sort, append n after the field numbers, e.g., sort +0 -1 +2n <filename>.
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!

Return Home