AWK Interview Questions with Answers

AWK is a powerful text-processing, data-extraction, and pattern-scanning programming language that is standard on Unix and Linux-like operating systems. It works by checking lines of a file, matches particular pattern rules, and runs corresponding scripting instructions.

AWK was designed and implemented in 1977 by three legendary computer scientists: Alfred Aho, Peter Weinberger, and Brian Kernighan. The name of the language is an acronym derived from the first letters of their last names.

The standard structure consists of a pattern definition followed by an action enclosed inside curly braces:

awk 'pattern { action }' file

A pattern acts as a gatekeeper rule or filtering condition. AWK loops through input lines and runs actions only if a line matches the pattern (e.g., regex filters, numerical comparisons, or target words).

An action is a sequence of statements enclosed in curly brackets { ... }. When a pattern is matched, AWK runs these statements (e.g., calculations, custom formatting, or text outputs).

In AWK, $0 is a special variable representing the entire current line of input record in its original un-split state:

awk '{ print $0 }' file.txt

AWK splits records into column columns dynamically. $1 stores the first field, $2 is the second, and so on:

awk '{ print $1, $2 }' file.txt

FS stands for Field Separator. It defines the character used to split incoming records into fields. The default FS is whitespace (spaces and tabs):

awk 'BEGIN { FS=":" } { print $1 }' file.txt

OFS stands for Output Field Separator. It specifies the delimiter used when printing fields separated by commas in print statements:

awk 'BEGIN { OFS=" | " } { print $1, $2 }' file.txt

NR stands for Number of Records. It tracks the total count of lines processed so far, functioning like a current loop iteration counter:

awk '{ print NR, $0 }' file.txt

NF is a built-in variable containing the Number of Fields in the current line record. It is highly useful for checking line complexity or printing specific end elements:

awk '{ print NF }' file.txt

The BEGIN block represents an initialization phase. Statements placed inside a BEGIN block execute exactly once before AWK reads any lines of the input file:

awk 'BEGIN { print "Processing Start..." } { print $1 }' file.txt

The END block runs exactly once after AWK has finished processing all lines of input records. It is typically used for printing final summaries, calculated totals, or averages:

awk '{ print $1 }' END { print "Total Lines Processed:", NR } file.txt

By default, calling print with no parameters outputs the entire current line record:

awk '{ print }' file.txt

You can print targeted fields by passing variable indices like $1 or $2 directly to print commands:

awk '{ print $2 }' file.txt

Use the -F command-line argument to specify a custom character string as the field delimiter:

awk -F',' '{ print $1, $3 }' file.csv

Pass the word inside regular expression slashes (/pattern/) before the action execution block:

awk '/error/' file.txt

Use comparison operators (>, <, ==) to evaluate field column values:

awk '$3 > 100' file.txt

By outputting the final NR value inside an END block, you get the overall number of lines processed:

awk 'END { print NR }' file.txt

Accumulate column field values iteratively inside variables, then output the final calculation state in the END block:

awk '{ sum += $2 } END { print sum }' file.txt

By printing the record variable NR alongside the original string $0, you get line numbers prefixing each record:

awk '{ print NR, $0 }' file.txt

Access the final field element dynamically using $NF, which acts as a pointer index to the total number of fields:

awk '{ print $NF }' file.txt

Use the built-in gsub() utility to swap matches globally on line strings:

awk '{ gsub(/old/, "new"); print }' file.txt

Check if the current line record number NR is divisible by 2 using modulus operations:

awk 'NR % 2 == 0' file.txt

Filter line records using the modulus operation matching non-zero remainder states:

awk 'NR % 2 == 1' file.txt

RS is the Record Separator. It controls how input data is divided into logical records (default is newline \n). Setting RS to empty ("") enables multi-line paragraph parsing modes:

awk 'BEGIN { RS="" } { print $1 }' file.txt

Place string or numeric conditional checks as patterns before action blocks to selectively process lines:

awk '$2 == "Admin"' file.txt

Use standard if-else constructs inside action blocks to create branching logic paths:

awk '{ if ($3 > 50) print $1, "Passed"; else print $1, "Failed" }' file.txt

Run standard loop loops (for, while) directly inside action blocks to parse field segments cleanly:

awk '{ for (i = 1; i <= NF; i++) print "Field", i, "is", $i }' file.txt

Use the formatting utility printf to configure tabular columns, padding alignments, and custom layouts:

awk '{ printf "%-10s %5d\n", $1, $2 }' file.txt

An associative array is a map index system backed by string keys instead of numbers. This allows developers to build lookup structures matching terms, counts, or keys directly.

By mapping string values into associative arrays, you can easily track occurrence frequencies across fields:

awk '{ count[$1]++ } END { for (val in count) print val, count[val] }' file.txt

The getline function explicitly reads the next line of input immediately, allowing developers to control line iteration manually within custom control logic loops.

Configure the system variable IGNORECASE = 1 inside your BEGIN block to make regular expressions case-insensitive:

awk 'BEGIN { IGNORECASE = 1 } /error/' file.txt

Check the record count NR for 1 to catch the first line, then run the END block to catch the final record:

awk 'NR == 1 { print "First:", $0 } END { print "Last:", $0 }' file.txt

Use the -v argument flag to map shell environment variables into AWK parameters before script parsing begins:

awk -v threshold=100 '$3 > threshold' file.txt

Track index states using NR == FNR to cache the first file in memory, then map values against the second target:

awk 'NR == FNR { a[$1] = $2; next } { print $0, a[$1] }' file1 file2

The gsub() function performs string replacement globally across matched target strings. It modifies the variable parameter references directly in memory.

Unlike `gsub()`, the sub() function is non-global. It targets and replaces only the very first occurrence of a matched pattern on structural variables.

By checking the field count variable NF, AWK automatically filters out and skips blank line inputs:

awk 'NF' file.txt

Isolate column columns using AWK, then pass the pipe stream into the terminal utility sort:

awk '{ print $2 }' file.txt | sort

Calculate maximum column values efficiently by running variable check bounds iteratively:

awk 'BEGIN { max = 0 } $3 > max { max = $3 } END { print "Max:", max }' file.txt

Load all line strings sequentially into an array, then iterate backwards through the array in the END block:

awk '{ lines[NR] = $0 } END { for (i = NR; i >= 1; i--) print lines[i] }' file.txt

Filter repeating strings quickly using associative index increments with boolean patterns:

awk '!seen[$0]++' file.txt

Track dynamic word counts by accumulating the NF values of each input record:

awk '{ total += NF } END { print "Words:", total }' file.txt

Identify and output records belonging strictly between specific starting and ending pattern definitions:

awk '/start/,/end/' file.txt

Split standard comma-separated inputs safely using custom field delimiters:

awk -F',' '{ print $2 }' file.csv

Swap delimiters globally by configuring matching variables inside BEGIN blocks:

awk 'BEGIN { FS=","; OFS="|" } { $1=$1; print }' file.csv

Parse fields iteratively across columns to match and count exact target words:

awk '{ for (i=1; i<=NF; i++) if ($i == "target") count++ } END { print "Occurrences:", count }' file.txt

Map and isolate unique string parameters across columns while skipping repeated entries:

awk '!seen[$1]++ { print $1 }' file.txt

length() returns the number of characters in a string or the length of a field.

awk '{ print length($0) }' file.txt

substr(string, start, length) extracts a substring.

awk '{ print substr($1, 1, 3) }' file.txt

split(string, array, separator) splits a string into an array.

awk '{ split($0, arr, ","); print arr[1] }' file.txt

match(string, regex) returns the position where the regex matches, and sets RSTART and RLENGTH.

awk '{ if (match($0, /[0-9]+/)) print RSTART, RLENGTH }' file.txt

index(string, substring) returns the position of the first occurrence.

awk '{ print toupper($0) }' file.txt

toupper() and tolower() convert strings to uppercase/lowercase.

awk '{ print sprintf("%-10s %5d", $1, $2) }' file.txt

sprintf(format, ...) works like printf but returns the formatted string.

awk 'BEGIN { system("echo Hello") }'

system(command) executes a shell command and returns its exit status.

awk '{ print $0 > "output.txt" }' file.txt

close(filename) closes an open file or pipe to free system resources or prevent "too many open files" errors.

awk 'BEGIN { while (getline < "data.txt") print }'

getline < "file" reads the next line from that file.

awk '{ getline var; print var }' file.txt

getline var reads the next line into the variable var.

awk '{ getline arr[NR] }' file.txt

Yes, you can assign to an array element: getline arr[NR].

awk 'BEGIN { print ENVIRON["HOME"] }'

The ENVIRON array holds environment variables keyed by name.

awk 'BEGIN { for (i=1; i<ARGC; i++) print ARGV[i] }' file1 file2

ARGC is the number of command-line arguments, and ARGV is an array of the arguments.

awk '{ print FILENAME, FNR, $0 }' file1 file2

FILENAME is the current input file name, and FNR is the record number within that file.

awk '{ print CONVFMT }' file.txt

CONVFMT controls the conversion of numbers to strings (default "%.6g").

awk 'BEGIN { OFMT="%.2f"; print 3.14159 }'

OFMT sets the format for printing numbers (similar to CONVFMT but for output).

awk 'BEGIN { RS=""; ORS="\n\n" } { print $0 }' file.txt

RS (input record separator) and ORS (output record separator) can be set to any string.

awk '{ print RT }' file.txt

RT holds the actual text that matched the record separator (RS).

awk '{ print RSTART, RLENGTH }' file.txt

After match(), RSTART holds the start index and RLENGTH the length of the match.

awk '{ print SUBSEP }' file.txt

SUBSEP is the separator used to construct the subscript string for multidimensional arrays (default "\034").

awk '{ arr[1] = "a"; arr[2] = "b"; for (i in arr) print i, arr[i] }'

Use asort() (gawk) to sort array values; asorti() sorts indices.

awk '{ arr[1] = "x"; arr[2] = "y"; asort(arr); for (i in arr) print arr[i] }'

Use delete array[index] to remove a specific element.

awk '{ arr[1] = "z"; delete arr[1]; for (i in arr) print }'

nextfile skips the rest of the current input file and moves to the next one.

awk '{ if (NR > 10) nextfile }' file.txt

exit terminates the script immediately; the END block still runs.

awk '{ if (NR > 5) exit } END { print "Exited" }' file.txt

Use > "filename" to overwrite or >> to append.

awk '{ print $0 > "out.txt" }' file.txt

Use >> "filename" to append output.

awk '{ print $0 >> "out.txt" }' file.txt

Use | "command" to send data to a shell command.

awk '{ print $0 | "sort" }' file.txt

Use the -f option: awk -f script.awk input.txt.

awk 'BEGIN { print "Start" } { print } END { print "End" }' file.txt

In gawk, use @include "other.awk" inside the script.

awk -f script.awk file.txt

Extract fields like IP, status, and bytes; count occurrences, sum bytes, etc.

awk '@include "other.awk"' file.txt

Use printf to format columns, compute totals in END block.

awk '{ for (i=1; i<=NF; i++) if ($i ~ /^[0-9]+$/) print $i }' file.txt

Read first file into an array, then process second file and look up values.

awk 'NR==FNR { a[$1]=$2; next } { print $0, a[$1] }' file1 file2

Check each field with a regex (~ /^[0-9]+$/) and flag errors.

awk '{ if (length($0) > 100) print "Long line:", NR }' file.txt

Use gsub(/old/, "new") to replace globally.

awk '{ gsub(/old/, "new"); print }' file.txt

Accumulate the field in a variable and print in END block.

awk '{ sum += $2 } END { print "Total:", sum }' file.txt

Use a pattern like $3 > 100 as the condition.

awk '{ if ($3 > 100) print $0 }' file.txt

Use /pattern/ or $0 ~ /pattern/ as the pattern.

awk '{ if ($0 ~ /pattern/) print }' file.txt

Use NR % 2 == 0 as the pattern.

awk 'NR % 2 == 0' file.txt

Loop from NF down to 1 and print each field.

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

Extract the second field and pipe to sort -k2.

awk '{ print $1, $2 }' file.txt | sort -k2

Set RS="" to treat blank lines as record separators, and FS="\n" to split fields by newline.

awk 'BEGIN { RS=""; FS="
" } { print $1, $2 }' file.txt

Use an associative array to count occurrences and print in END block.

awk '{ count[$1]++ } END { for (key in count) print key, count[key] }' file.txt

Use $2 ~ /^[A-Z]/ as the pattern.

awk '{ if ($2 ~ /^[A-Z]/) print }' file.txt

Set FS="," and OFS="|", then $1=$1 to rebuild the record.

awk 'BEGIN { FS=","; OFS=" | " } { $1=$1; print }' file.csv

Check each field for "error" and print NR and the line.

awk '{ for (i=1; i<=NF; i++) if ($i == "error") print NR, $0 }' file.txt

Compare each line with the previous one and print only if different.

awk '{ if (NR > 1 && $0 != prev) print $0; prev = $0 }' file.txt

Iterate fields and print those that match a numeric regex.

awk '{ if ($1 ~ /[0-9]+/) print $1 }' file.txt

Use the built‑in variable FILENAME.

awk 'BEGIN { print "File:", ARGV[1] } { print }' file.txt

Track the maximum in a variable and print it in END block.

awk '{ if ($1 > max) max = $1 } END { print "Max:", max }' file.txt