Awk Tips and Cheat Sheet

The most common condition is a search pattern, /pattern/ that has been matched. So most often you will see awk examples where they assume that the awk syntax is always awk '/pattern/{print}' but it could easily be awk 'NF>3 {print}' or even simpler awk 'NF>3' which would only print lines that more than 3 fields, as {print} is the default action, and $0 is the default to the print statement which is the whole line

So in these syntax examples, remember that the /pattern/ is just a common condition statement, and that really any condition is allowed.

 condition { action }  # if condition is met perform the corresponding action

 # do action on all lines matching pattern
 awk [-Fc] '/pattern/ {action}' var=value file(s)
 # do action on all lines matching pattern, AND do action2 for ALL lines 
 awk [-Fc] '/pattern/ {action} {action2}' var=value file(s)
 # do action for every line of input, and if pattern is found also do action1
 # action2, and action3.  so for lines matching the pattern, all four actions
 # would be performed.
 awk [-Fc] '{action} /pattern/ {action1; action2; action3;}' var=value file(s)

 awk [-Fc] '$n == somevalue && $m ~ /pattern/ {action; action; action;} {action2;}' var=value file(s)
 awk '$2=="Ontario" {print $1, $2}'  # prints first two fields if the
                                     # 2nd field is exactly "Ontario"
 awk '$2 ~ "Ont" {print $1, $2}'  # prints first two fields if the
                                     # 2nd field contains "Ont" anywhere

 awk [-Fc] -f scriptfile var=value file(s)

 awk [-Fc] '/pattern1/ {action1} /pattern2/ {action2}' var=value file(s)

 awk '/search string/ {print}'  file(s)      # this and previous are identical
 awk '/search string/ {print $1, "this is awk output", $5}'  file(s)

 # awk understancds brackets too, but they are optional.
 awk '(/pattern1/){action1} (/pattern2/){action2}...'
 awk '(NR==1){print "Line 1 ";$0} (NR==2){print"Line 2 ";$0}...'
 awk  'NR==1{print "Line 1 ";$0}   NR==2{print"Line 2 ";$0}...'   do exactly the same thing.

 # now if we don't care about labelling with Line 1 and Line 2 the next
 # 3 lines do the same thing
 awk 'NR==1{print $0};NR==2{print $0}'   
 awk 'NR==1{print};NR==2{print}'   
 awk 'NR==1;NR==2' 

 # the last statement must have the ; but notice that the next two lines
 # still do exactly the same thing. i.e. the ; is understood when you have
 # actions in braces.

 awk 'NR==1{print $0} NR==2{print $NF}'  # print line 1, and print the last field
                                         # of line 2.  Nothing more.
 awk 'NR==1{print} NR==2{print}'

 awk '$n == "string" {action}'  #nth field must exactly match the string
 awk 'tolower($n) == "string" {action}' # compare case insensitive field n
 NR == 5 {action}
 NR > 5 && $1 ~/someregex/ {action} # after line 5, if the 1st field contains
                                    # some regular exp, then perform action
 $n ~ "string" {action}    # if "string" is found in the nth field do action.

awk '/string/ {printf %d\t%d\t%s\n, $1, $2, $3}' file(s)
awk -F, '{printf  %d\t%d\t%s\n, $1, $2, $3 $4}' file(s)  # comma delimited fields
awk -F, '{print $1; print $2; print $3; print $4}' file(s)  # prints fields 
                                                            # on separate lines
awk -F, '{print $4}' file      # prints everything between 4th and 5th comma
awk -F"\t" '{print $4}' file   # prints everything between 4th and 5th tab

awk '$5 !~ /string/ {print}' file        # prints all lines where the 5th field
                                         # does NOT contain "string" in it.
awk '{if (NR > 2) print}' file           # prints all records except first two

awk 'NR%2{printf "%s ",$0;next;}1' yourFile

Options entered on the awk command line are:

• -F to specify a field separator/delimiter
• -f awk-script-file file contains all the awk commands
• -v assign a value to a variable.

Awk works very well when you have columnar data, or field-separated data. Not surprising then that the most common option is the -F flag which specifies a field delimiter. The default field delimiter is space, or actually any whitespace, but can be overridden with the -F flag.

For example awk -F, treats the input stream as csv data. (Comma Separated Values). See also awk input field seperator $IFS.

Other common delimiters are: -F"," and -F":" and -F"\t" for comma, colon, tab separated values respectively. But any character can be assigned the field delimiter.

lines without a condition, evaluates as "true" i.e. the default decision when a pattern is not present is match all lines. You can think it as no condition or pattern matches all patterns, so is always true. awk '{print $1}' prints the first field of absolutely every line

A very good idea, if you can, is to anchor the pattern to either the end of the line, $ or the beginning of the line. ^

But there is also \A for beginning of a string, \z for end of a string and \b for a word boundary.

There are three ways to ignore case when matching pattersn (that I know of)

1. Use the IGNORECASE option
2. Use the tolower() function on the entire line before the comparison ~

   awk 'tolower($0) ~ /pattern/' student.data
   

3. Set the variable IGNORECASE = 1 as part of the condition.

awk 'IGNORECASE = 1;/PatTeRn/ {action} student.data

awk has two special patterns that always match line 0, BEGIN or the line after the last line, END These like patterns are conditions, that are followed by {actions} in braces.

So you can have awk do some action on line 0 and some other action after the last line is processed.

Typically BEGIN is used to initialize variables, maybe print some headers.

END is used to print some summary of variables that have been counting through each line processed. Both BEGIN and END are only executed once.

# Take the output of the df -l command and pipe it to this awk script
# i.e. df -l | awk -f awkscript-for-df
$1 != "tempfs" {
    used += $3;
    available += $4;
    }
END {
     printf "%d GiB used\n%d GiB available\n", used/2^20, available/2^20;
 }

Another use of end, is to add lines to the end of a file

awk '{print} END {print "* [[https://www.zintis.net][www.zintis.net]]"};' \
projectplan.org > tmp && mv tmp projectplan.org;

Put that in a bash for loop to add the line to all files in a directory:

for orgfile in *.org   

If an condition is missing, awk evaluates it as true. So to emulate cat

awk '{print}' filename  # just like cat filename
# or even
awk 1 filename   # here the condition is 1, so always true, but the action
                 # is missing, which defaults to {print}
                 # notice that even the ' characters are optional if there
                 # is no ambiguity

If an action is missing, awk defaults it as print, you can emulate grep

awk '/apache/' filename   # just like grep apache filename

To ignore all lines starting with # you could awk '!/^#/' file1

If you want to change all occurances of a string, be aware of where you put the print statement. Make sure it is a separate condition/action pair otherwise you will only print lines where you made the substitution and ignore all other lines. For example this will make the change of 4 to "fourth" but will only print the lines that were changed.

# for every line that contains "4th" substitute it with "fourth"
# and print only those lines.
/4th/ {
    gsub(/4th/, "fourth"); print;
}

Where this will print every line, with changes and lines without changes.

# for every line that contains "4th" substitute it with "fourth"
/4th/ {
    gsub(/4th/, "fourth");
}
{print}

A much better approach is the simpler one too:

# for lines containing "eric"
/eric/ {
    # substitute 4th for fourth
    gsub(/4th/, "fourth")
}
# print all lines, including the ones that substituted fourth for 4th
{print $0}

As described above, awk works line by line. On each line, if patterns are matched to the line, the all the actions get run. However, you can also have awk do multiple comparisons, and they all get run in the order they appear in the awk script. Unless…. one of the actions includes the next command. In that case, the line is considered completed, and awk moves on to the next line in the input.

This is useful when you need to ignore all the remaining pattern comparisons and subsequent actions on a line. For example, say you are printing records that have a value greater than 60 in the third column. Easy:

$3 >= 60 {print $0}

But let's say you also want to flag records that are greater than 50 with a string "on probation"

$3 >= 60 {print $0}
$3 >= 50 {print $0, " On probation"}

This would cause records that have values > 60 to get printed twice, once with just the line, the second time with the words "on probation" which is NOT what you wanted.

You can tell awk "next" as another action with $3 >= 60 in which case they will not have "on probation" in their output.

$3 >= 60 {print $0; next;}
$3 >= 50 {print $0, " On probation";}

This can also be written for easier reading as:

$3 >= 60 {
    print $0;
    next;
}

$3 >= 50 {
    print $0, " On probation";
}

Finally, lets say if the value of column 3 is < 50, print "failed" but not the mark.

$3 >= 60 {
    print $0;
    next;
    }

$3 >= 50 {
     print $0, " On probation";
     }

$3 < 50 {
     $3 = "failed";
     print $0;
     }

I already mentioned BEGIN and END, but awk also automatically counts the number of records (lines) in the input and assigns it the variable NR. You recall this variable using NR

• $0 is the whole record (line)
• $1 is the first field
• $2 is the second field.
• $n is the nth field.
• $NF is the last field
• NF is just a number equal to the number of fields on this line.
• NR number of records (i.e. the number of lines if record separator is \n
• FNR is the file number of records (is reset to 1 at the top of every new file when multiple files are processed by awk)

To print all fields excluding the first field this will work:

• awk '{$1 = ''; print $0}' which sets the first field to the null string then prints the whole line. i.e. it omits the first field.

To count lines that match a pattern, you can create your own variable and use it to count, like:

BEGIN { rows = 0}
rows += 1
END
print rows

 $ cat file1
 one
 two
 three

 $ cat file2
 four
 five
 six

$ awk '{ print FNR, FILENAME, " ==> ", $0 }' file1 file2
     $ cat file1
1 file1 ==> one
2 file1 ==> two
3 file1 ==> three
1 file2 ==> four
2 file2 ==> five
3 file2 ==>  six

You can change the output field seperator, OFS, to what you want. Often to the newline character in which case each field printed will be on a new line. so assuming your input field separator is a colon, like for example in a PATH output, and you want to see each path entry on its own line:

echo ${PATH} | awk 'BEGIN{FS=":";OFS="\n"} FNR==1{$1=$1;print;exit}' \
      myinputfile
echo "${PATH}" | awk '{gsub(/:/, "\n"); print}'
echo -e "${PURPLE}${PATH//:/\\n}"  # also works, using the echo command itself

But another way to output each field on a new line is using gsub(/ /,"\n") or gsub(/ : /,"\n") if your fields are separated by a colon. but no spaces surounding the ":".

$ echo "The fox jumped over the dog" | awk '{gsub(/ /,"\n"); print}'
The
fox
jumped
over
the
dog

A simplistic approach, if not so flexible, is to print the newline string wherever you need it, among the other fields. For instance:

• awk '{print $1"\n"$2,$3,$4}' file

awk will put a trailing space on the end of a print, i.e. '{print $2 $3}' To remove that, you can use sub or gsub to change zero or more occurances, +, of either space or tab, [ \t] that occur at the end of the line, $ So /[ \t]+$/

# remember that everything inside the curly braces is an action.
{gsub(/[ \t]+$/,"",$0); print;} 

(not awk related, but while here see:

• alias taka='tput setaf 5;echo -e "${PURPLE}${PATH//:/\n}"'

Another good example from stackoverflow: stackoverflow.com Here we are looking at lines that contain a comma, and then stripping all blank characters from field 2, and printing fields 1 and 2 with a single space between them.

awk -F, '/,/{gsub(/ /, "", $2); print $1","$2} ' input.txt

Explanation:

 -F,     use comma as field separator 
         (so the thing before the first comma is $1, etc)

/,/      operate only on lines with a comma 
         (this means empty lines and lines without a comma are skipped)

gsub(/a/, b, c)    match the regular expression a, replace it with b, 
                   and do all this with the contents of c, in this case 2nd
		   field.

print $1","$2   print the contents of field 1, a comma, then field 2

input.txt      use input.txt as the source of lines to process

The usual approach is use -F: or -F,… Can also use $FS=":" or $FS=","

If you collect your awk commands in a separate file, then you include the -f file argument to awk, which then reads the awk commands in that file for every line of input from stdin.

Because you would want to specify separators in a script and not rely on the user of a script to remember to call the script with a -F, parameter, you should always use these predefined system variables in an awk script, Usually at the beginning, so in the BEGIN section.

FS = "\t"   # tab for tab seperated values, exactly 1 tab
FS = "\t+"  # tab for tab seperated values, one or more tabs
FS = "[':\t]" # any one of a tic, colon, or tab will be seen as a delimiter
FS = ","    # for comma separated values
FS = "\n"   # Good for multi-lined records, so each line is a field.
RS = ""     # if the above is used, you will need a record separator.
            # If set to "" will be a blank line.  these two are often
            # combined to handle multi-line records.
ORS = "\n"  # the output record separator.Good for multi-lined records,
            # so each line is a field.

OFS = "\n"  # output field separator, set to newline.  Is a space by
            # default.
NR          # number of records
NF          # number of fields
FILENAME    # the name of the current input file
FNR         # the number of the current record relative to the input file
ARGC        # the number of passed parameters
ARGV        # recalls the command line parameters
ENVIRON     # an array containing the shell environment vars and values
IGNORECASE  # to ignore the character case or not

BEGIN {
  FS = ":";
  OFS = "\t";
  }
  {print $1, $NF};

Simply start using them with an assignment statement, and recall the values later without using the $ sign:

# Using student records as a sample file source.
# sample data:

# alice 3rd 78
# bob 1st 57
# john 4th 61
# eric 4th 76
# graham 4th 58
# suzanne 2nd 75
# johnson 2nd 43

NR == 1 {
   print "Adjusting 4th year student marks up by 5%";
}

# count the number of 4th year students
$2 == "4th" {
    count++;
    }
# add adjusted mark to all fourth year students
/4th/ {
    markadjust = $3 * 1.05;
    print "4th year student", $1, "  Mark", $3, " Adjusted mark", markadjust;
}

# also print out the name and mark of third year students
/3rd/ {
    print "Third year student", $1, $3;
}

END {
    print "There were " count " 4th year students with adjusted marks"
}

You can compare any variable to a value. The comparison is at the "pattern matching stage". Then any action can be taken based on the comparisons.

• < less than
• > greather than
• <= less than or equal to
• >= greater than or equal to
• == equal to
• != not equal to
• ~ matches # # used to compare a pattern from a particular field.
• !~ not matches

So to print the lines only if they have six fields: But also for the very first line only, print the first six fields:

awk 'NR == 1 {print $1 $2 $3 $4 $5 $6}'
awk 'NF == 6 {print $0}'

Or more exacting, with all comments:

# run on hydro electric usage data as awk -f electric-usage.awk  *.cvs
# if you want to run on all your electic data files.

BEGIN {FS = ","; ORS = "\n\n"}   # input is csv, output is double spaced.
# the column headings are on line 2.  Print them.
NR == 2 {print "\n---------------"; print $1, $4, $5, $6}

# only print lines that have six fields. and then only fields 1, 4, 5 & 6
NF == 6 {print $1, $4, $5, $6}

Similar to the above, but with tabbed output:

BEGIN {FS = ","; ORS = "\n" ; print "\n---------------";  }
# input is csv, output is double spaced.
# the column headings start with "Months"
$1 == "Months" {printf "%s\t%s%s\n", $1, $2, $6; print "----------------"}
# {print "\n---------------"; print $1, $2, $6}

# only print lines where field 2 is greater than 15 celsius
# and then, only print the month and have six fields. and then
# only fields 1, 4, 5 & 6
# I could do this:
# $2 > 15 || $1 == "Months" {print $1, $2, $6} but that prints the heading twice
# as the heading is already printed in the script earlier.
# so instead, just
$2 > 15 {printf "%s\t%d\t%d\n", $1, $2, $6} but that prints the heading twice

The typical || for or and && for and boolean operators allow you to combine several comparisons together. For example, if field 3 is < 100 AND the line has less than 8 fields, print the line would be:

NF < 8 && $3 < 100 {print $0}
NF > 2 || $1 ~ /header/ {print $0}

Lets say you want to average out a variable number of numbers on each line. You can do a while loop up to the number of fields on a line:

Input data:

575,56,124,461
271,182,818,457
314,159,265,342,415,711
478,549,241,256
505,121,211,198,217

You awk script could be:

# these actions run from scratch on every line of input
sum = 0;
i = 1;
while (i < (NF + 1))
   {
   sum += $i
   i++
   };
average = sum / NF
print $0, " average -->", average;

You can have awk stop looking at more lines with the {exit} action. So lets say you want to stop reading input when you see the first instance of the string "<footer>". Do this:

awk '/<footer>/ {exit}; {print $0}'

The desire to do something after a pattern has been seen, then stop doing it when another pattern is seen, is common enough that awk has a built-in construct to do this.

Simply specify the pattern to start an action, then another pattern after which the action will stop, separated by a comma

awk '/ifseenstartaction/,/stopactionafterseeing/'
awk '/startpattern/,/stoppattern/ print $0, "pattern activated";'

Double the percent signs if typing from the DOS command prompt.

awk '{printf("%5d : %s\n", NR,$0)}'

Remember caveats about Unix treatment of \r (mentioned above)

awk 'NF{$0=++a " :" $0};{print}'
awk '{print (NF? ++a " :" :"") $0}'

awk -v n=4 '{ for (i=n; i<=NF; i++) printf "%s%s", $i, (i<NF ? OFS : ORS)}' input

This is taken straight out of stackoverflow: "This will take n as the value of n and loop through that number through the last field NF, for each iteration it will print the current value, if that is not the last value in the line it will print OFS after it (space), if it is the last value on the line it will print ORS after it (newline)."

Intended for finding the longest string in field #1

awk '$1 > max {max=$1; maxline=$0}; END{ print max, maxline}'

condition is NF > 4, and there is no action, so defaults to print $0.

awk 'NF > 4'

condition is $NF > 4, and there is no action, so defaults to print $0.

awk '$NF > 4'

TEXT CONVERSION AND SUBSTITUTION:

awk 1    ? shouldn't it be awk '1' ?

worth testing in a dos environment, which I do not have.

tr -d \r <infile >outfile            # GNU tr version 1.22 or higher

awk '{printf "%79s\n", $0}' file*

Probably better to strip trailing white space first, and then print flush right. so:

awk '                     {printf "%79s\n", $0}' file*
awk '{sub(/[ \t]+$/, "")} {printf "%79s\n", $0}' file

awk '                   {l=length();s=int((79-l)/2); printf "%"(s+l)"s\n",$0}' file*
awk '{sub(/[ \t]+$/, "")}{l=length();s=int((79-l)/2); printf "%"(s+l)"s\n",$0}'                                                                  

Again, best to strip trailing blanks first, to get a true centered output.

awk '/baz/{gsub(/foo/, "bar")};{print}'  # prints all lines 
awk '/baz/{gsub(/foo/, "bar");print}'    # prints only lines with baz

Be aware that the print statement can be part of an action, or its own action

(fails if there are multiple lines ending with backslash…)

awk '/\\$/ {sub(/\\$/,""); getline t; print $0 t; next}; 1' file*

awk '{temp = $1; $1 = $2; $2 = temp}' file

Seems to me to be unneccessary, if you simply switch the fields then save the output to a new file. i.e. awk '{print $2, $1}' file > newfile

awk '{for (i=NF; i>0; i--) printf("%s ",i);printf ("\n")}' file
awk '{for (i=NF; i>0; i--) printf("%s ",$i);printf ("\n")}' file

Don't forget that you want to print the field i, not just the number i, so $i

awk 'a !~ $0; {a=$0}'

This example also removes the blank lines, after the first blank line.

(but not the line itself i.e the line containing the regex)

awk '/regex/{print x};{x=$0}'
awk '/regex/{print (x=="" ? "match on line 1" : x)};{x=$0}'

(but not the line containing the regex)

awk '/regex/{getline;print}'

awk '/AAA/; /BBB/; /CCC/'

We have three condition/action pairs, each of which is missing the action which defaults to print $0

awk '/Iowa/,/Montana/'             # case sensitive

SELECTIVE DELETION OF CERTAIN LINES:

awk NF
awk '/./'
#

awk 'NR%2{printf "%s ",$0;next;}1' yourFile

This last example above will join every two lines into one line

one
two
three
four

will become

 one, two
three, four

This works as follows. NR%2 evaluates to zero every second line (even line). So when it is NOT zero, i.e. every odd line, it prints the odd line, $0, and immediately goes to the next line. Then the next condition / action is performed which is 1, always true, so always does the defaut print action.

Changing emails on all my org files:

awk  '/^\#\+EMAIL/  {sub(/somedomain DOT ca/, "gmail DOT com");print}'  *.org

tail +1 phones.crd | awk -F"\0" '{print}' >! junk

 awk [-Fc] 'pattern {action}' var=value file(s)
 awk [-Fc] -f scriptfile var=value file(s)
 awk '{print $1}'  file(s)

awk '/search string/'  file(s)

this is the same as:

# print is the default action
awk '{print}'
awk '{print $0}'  # $0 is the whole line
awk '1'               

see condition-action pairs. for what the '1' above accomplishes

awk '/zintis/ {print "$1, $2"}

with a space between them (comma). Lines that do not match 'zintis' do not get printed at all.

remember that everything within the {} is an action(s)

awk '{for (i=NF; i>0; i--) printf("%s ",$i);printf ("\n")}' file

awk 'a !~ $0; {a=$0}'

This works as follows: the condition is a !~ $0 which evaluates as true if a does not equal $0, i.e. the whole line. i.e. a fresh line. If true, then execute the action which set a to be the whole line {a=$0}

The condition is NOT met whenever we have a duplicate line, so no action is done, i.e. the line is NOT printed.

The only other quirk to remember is that in addition executing the action in the curly braces and setting a to be the whole line, awk ALSO PRINTS the whole line. That comes from point 2) below: the implied action is print.

Useful to review:

1. A condition is considered false if it evaluates to zero or the empty string, anything else is true (uninitialized variables are zero or empty string, depending on context, so they are false).
2. Either a condition or an action can be implied, true & print; respectively
3. Braces without a condition are considered to have a true condition and are always executed if they are hit
4. Any condition without an action will print the line if and only if the condition is met i.e. NOT ZERO OR NULL

awk '$NF > 4'

HANDY ONE-LINERS FOR AWK 22 July 2003 compiled by Eric Pement <pemente@northpark.edu> version 0.22 Latest version of this file is usually at: http://www.student.northpark.edu/pemente/awk/awk1line.txt

USAGE:

awk 'pattern {print "$1"}'= # standard Unix shells

FILE SPACING:

awk '1;{print ""}'
awk 'BEGIN{ORS="\n\n"};1'

These both accomplish the same thing.

Output file should contain no more than one blank line between lines of text. NOTE: On Unix systems, DOS lines which have only CRLF (\r\n) are often treated as non-blank, and thus 'NF' alone will return TRUE.

awk 'NF{print $0 "\n"}'

Lines that are already blank, will have NF = 0 which evaluates as false. So if the condition is false, the action will NOT be done, so not printing the blank line with another \n . Lines that are NOT blank evaluate NF as 1 so true, and are printed with an extra \n at the end, i.e. double spaced.

The following line is the same as: grep 'search string' file(s)

awk '//search string// {print}'  file(s)

And since the default action is {print} you could simplify that further with

awk '/search string/' files

Since the default action is {print}, and if you omit the search string, you might think that awk file is the same as cat file, however awk is still expecting something in the single tics, ' ' as the second parameter, so you must include the '{print}' here. So cat file is the same as:

awk '{print}' file(s)

You can output only selected fields if you wish, with $1 being the first field. And $NF being the last field on a line.

So printing the first, and fifth fields of every line:

awk '{print $1, " is first field and 5th field is ", $5}'  file(s)

And to print the above on only lines that contain search string you can

awk '/search string/ {print $1, " is first field and 5th field is ", $5}'

The printf statement looks like: printf format, item1, item2, ... The format definition is a single string that includes format definitions for each of the items that follow, and any other fixed strings you want to add

From the example before that gave us lines like 38.8889 Celsius

# no format strings here
awk 'NR==1; NR>1{print ($2 == "F" ? ($1 - 32)/1.8 : $1) " Celsius"}'  temperature.data

We can try printf("%.1f %c\n",...) where in this case we have two format statements, and two objects to print, separated by commas, these being:

1. ($2=="F" ? ($1-32) / 1.8 : $1)
2. "Celsius"

# format string is "%.1f %c\n"
awk 'NR==1; NR>1{printf("%.1f %s\n",($2=="F" ? ($1-32) / 1.8 : $1),"Celsius")}'  temperature.data
# format string is "%.1f degrees %c\n"                                                                
awk 'NR==1; NR>1{printf("%.1f degrees %c\n",($2=="F" ? ($1-32) / 1.8 : $1),"Celsius")}'  temperature.data
# format string is "%.1f degrees Celsius\n"                                                                   
awk 'NR==1; NR>1{printf("%.1f degrees Celsius\n",($2=="F" ? ($1-32) / 1.8 : $1))}'  temperature.data

Breaking down the first example better printf format, item1, item2 where in our case:

• format is "%.1f %s\n"
• item1 is either ($1-32) / 1.8 or $1 according to if $2 is an "F"
• item2 is "Celsius"

  Temperature  Scale
   3.9 Celsius
   38.9 Celsius
   7.2 Celsius
   6.0 Celsius
  
  Temperature  Scale
  3.9 degrees C
  38.9 degrees C
  7.2 degrees C
  6.0 degrees C
  9.0 degrees C
  

Notice that you are not seeing Celsius but C. That is because only one character from the string is allowed, with %c. %s would give you the whole string

# format string is "%.1f %s\n"
awk 'NR==1; NR>1{printf("%.1f %s\n",($2=="F" ? ($1-32) / 1.8 : $1),"Celsius")}'  temperature.data

Temperature  Scale
3.9 Celsius
38.9 Celsius
7.2 Celsius
6.0 Celsius
9.0 Celsius
2.0 Celsius

You can include any strings you want right in the format portion. For example we can add the string " degrees" in the format statement as follows:

As shown in an example above, a format string could be =

# format string is  "%.1f degrees %s\n"
awk 'NR==1; NR>1{printf("%.1f %s\n",($2=="F" ? ($1-32) / 1.8 : $1),"Celsius")}'  temperature.data

In awk they are one dimensional arrays for storing groups of related strings. There is no need to declare the size of the array ahead of time

awk arrays are associative, meaning that the index need NOT be a number, but any string. In that sense they are more like python dicitonaries, where each entry is a pair. an index and the corresponding array element value.

The awk manual uses this array example:

Element "dog" Value "chien"
Element "cat" Value "chat"
Element "one" Value "un"
Element "1" Value "un"
Element "not yet" Value "pas encore"

You can recall an array element using square brackets on the index, for example french["not yet"] would return "pas encore".

A reference to an array element that does not exist automatically creates it.

I have barely scratched the surface here. Best to read gawk manual #arrays