Intermediate

printf "Alice Engineer\nBob Manager\nCarol Engineer\nDave Manager\nEve Director\n" | awk '
{
  count[$2]++    # => Use $2 (role) as array key; increment counter
  # => After "Alice Engineer": count["Engineer"] = 1
  # => After "Bob Manager":    count["Manager"]  = 1
  # => After "Carol Engineer": count["Engineer"] = 2
  # => After "Dave Manager":   count["Manager"]  = 2
  # => After "Eve Director":   count["Director"] = 1
}
END {
  # Print each role and its count
  for (role in count) {
    print role, count[role]   # => Iterate over all keys in count array
  }
}
'
# => Output (order not guaranteed — arrays are unordered):
# => Engineer 2
# => Manager 2
# => Director 1

printf "red 5\nblue 3\nred 2\ngreen 7\nblue 1\n" | awk '
{
  totals[$1] += $2    # => Accumulate totals by color (key=$1, value+=$2)
  # => After "red 5":   totals["red"]   = 5
  # => After "blue 3":  totals["blue"]  = 3
  # => After "red 2":   totals["red"]   = 7  (5+2)
  # => After "green 7": totals["green"] = 7
  # => After "blue 1":  totals["blue"]  = 4  (3+1)
}
END {
  for (color in totals) {              # => Iterate all keys
    printf "%-10s %d\n", color, totals[color]
    # => "red"   7
    # => "blue"  4
    # => "green" 7
  }
}
' | sort    # => Sort output for deterministic display
# => Output:
# => blue       4
# => green      7
# => red        7

printf "alice\nbob\nalice\ncharlie\nbob\nalice\n" | awk '
{
  if ($1 in seen) {
    # => "in" tests existence without creating the key
    print $1, "duplicate"     # => Prints when already seen
  } else {
    seen[$1] = 1              # => Mark as seen on first occurrence
    print $1, "new"           # => Prints on first occurrence
  }
}
'
# => Record 1 "alice":   not in seen => new, seen["alice"]=1
# => Record 2 "bob":     not in seen => new, seen["bob"]=1
# => Record 3 "alice":   in seen => duplicate
# => Record 4 "charlie": not in seen => new, seen["charlie"]=1
# => Record 5 "bob":     in seen => duplicate
# => Record 6 "alice":   in seen => duplicate
# => Output:
# => alice new
# => bob new
# => alice duplicate
# => charlie new
# => bob duplicate
# => alice duplicate

printf "apple\nbanana\napple\ncherry\nbanana\napple\n" | awk '
{
  freq[$1]++   # => Count occurrences of each word
}
END {
  # Remove words that appear only once (keep only duplicates)
  for (word in freq) {
    if (freq[word] == 1) {
      delete freq[word]    # => Remove single-occurrence entries
      # => "cherry" appears once => deleted from freq array
    }
  }
  print "Words appearing more than once:"
  for (word in freq) {
    print word, freq[word]   # => Only remaining entries (apple, banana)
  }
}
'
# => freq after counting: apple=3, banana=2, cherry=1
# => delete removes "cherry" (count=1)
# => Remaining: apple=3, banana=2
# => Output:
# => Words appearing more than once:
# => apple 3
# => banana 2

printf "apple\nbanana\napple\ncherry\nbanana\ndate\napple\n" | awk '
!seen[$0]++
# => For each record $0:
# =>   Check if seen[$0] is 0 (falsy) — ! inverts to true => PRINT
# =>   Then increment seen[$0] (post-increment happens after test)
# =>   On second occurrence: seen[$0]=1 => !1 = false => SKIP
# => "apple" first time:  seen["apple"]=0 => !0=true => print, seen becomes 1
# => "banana" first time: seen["banana"]=0 => print, seen becomes 1
# => "apple" second time: seen["apple"]=1 => !1=false => skip
# => "cherry":            seen["cherry"]=0 => print
# => "banana" second:     seen["banana"]=1 => skip
# => "date":              seen["date"]=0 => print
# => "apple" third:       seen["apple"]=2 => skip
'
# => Output (first occurrence order preserved):
# => apple
# => banana
# => cherry
# => date

printf "85\n92\n71\n88\n64\n" | awk '
function grade(score) {
  # => Returns letter grade based on numeric score
  if (score >= 90) return "A"    # => 90+ => A
  if (score >= 80) return "B"    # => 80-89 => B
  if (score >= 70) return "C"    # => 70-79 => C
  return "F"                     # => below 70 => F
}
 
{
  g = grade($1)                  # => Call user-defined function with $1
  printf "%d => %s\n", $1, g    # => Print score and grade
}
'
# => grade(85) returns "B"
# => grade(92) returns "A"
# => grade(71) returns "C"
# => grade(88) returns "B"
# => grade(64) returns "F"
# => Output:
# => 85 => B
# => 92 => A
# => 71 => C
# => 88 => B
# => 64 => F

printf "hello world\nfoo bar baz\ntest\n" | awk '
function count_chars(str,    i, n, total) {
  # => "str" is the real parameter
  # => "i", "n", "total" are local variables (extra params, never passed)
  total = 0
  n = length(str)         # => n = number of chars in str
  for (i = 1; i <= n; i++) {
    if (substr(str, i, 1) != " ")  # => Skip space characters
      total++             # => Count non-space characters
  }
  return total            # => Return non-space character count
}
 
{
  c = count_chars($0)           # => Count non-space chars in full line
  printf "%-20s => %d chars\n", $0, c
}
'
# => "hello world"    => h,e,l,l,o,w,o,r,l,d = 10 non-space chars
# => "foo bar baz"    => f,o,o,b,a,r,b,a,z   = 9 non-space chars
# => "test"           => t,e,s,t              = 4 non-space chars
# => Output:
# => hello world         => 10 chars
# => foo bar baz         => 9 chars
# => test                => 4 chars

printf "hello\nlonger string here\nhi\n" | awk '
{
  n = length($0)        # => Number of characters in current record
  # => "hello" => 5
  # => "longer string here" => 18
  # => "hi" => 2
  printf "%-20s length=%d\n", $0, n
}'
# => Output:
# => hello                length=5
# => longer string here   length=18
# => hi                   length=2

echo "2026-04-01T12:30:00" | awk '{
  year  = substr($0, 1, 4)    # => Characters 1-4: "2026"
  month = substr($0, 6, 2)    # => Characters 6-7: "04"
  day   = substr($0, 9, 2)    # => Characters 9-10: "01"
  time  = substr($0, 12)      # => Characters 12 to end: "12:30:00"
  printf "Year=%s Month=%s Day=%s Time=%s\n", year, month, day, time
}'
# => Input: "2026-04-01T12:30:00"
# => substr extracts fixed-position substrings
# => Output: Year=2026 Month=04 Day=01 Time=12:30:00

printf "error: disk full\ninfo: all good\nerror: timeout\n" | awk '
{
  pos = index($0, "error")    # => Find "error" in the line
  # => "error: disk full":  pos = 1 (starts at position 1)
  # => "info: all good":    pos = 0 (not found)
  # => "error: timeout":    pos = 1
  if (pos > 0) {
    msg = substr($0, pos + 7)  # => Skip "error: " (7 chars) to get message
    print "ALERT:", msg         # => Print just the error message part
  }
}'
# => Output:
# => ALERT: disk full
# => ALERT: timeout

echo "alice:bob:carol:dave" | awk '{
  n = split($0, names, ":")   # => Split on ":" into names array
  # => n = 4 (number of parts)
  # => names[1]="alice", names[2]="bob", names[3]="carol", names[4]="dave"
  print "Count:", n
  for (i = 1; i <= n; i++) {
    print i, names[i]         # => Print index and value
  }
}'
# => Output:
# => Count: 4
# => 1 alice
# => 2 bob
# => 3 carol
# => 4 dave

echo "the cat sat on the mat" | awk '{
  original = $0               # => Save original: "the cat sat on the mat"
 
  n = gsub(/the/, "a", $0)   # => Replace all "the" with "a"
  # => "the cat sat on the mat" => "a cat sat on a mat"
  # => n = 2 (two replacements made)
  print $0, "(", n, "replacements)"
}'
# => Output: a cat sat on a mat ( 2 replacements)
 
echo "hello world hello" | awk '{
  sub(/hello/, "hi")   # => Replace only FIRST "hello"; target defaults to $0
  # => "hello world hello" => "hi world hello"
  print
}'
# => Output: hi world hello

printf "order-12345-shipped\norder-99-pending\nno-id-here\n" | awk '
{
  if (match($0, /[0-9]+/)) {
    # => RSTART = starting position of match
    # => RLENGTH = length of matched text
    id = substr($0, RSTART, RLENGTH)   # => Extract the matched digits
    printf "Line: %-25s => ID: %s\n", $0, id
  } else {
    printf "Line: %-25s => No ID found\n", $0
  }
}'
# => "order-12345-shipped": match at pos 7, length 5 => "12345"
# => "order-99-pending":    match at pos 7, length 2 => "99"
# => "no-id-here":          no match (RSTART=0)
# => Output:
# => Line: order-12345-shipped       => ID: 12345
# => Line: order-99-pending          => ID: 99
# => Line: no-id-here                => No ID found

printf "Alice ENGINEER New York\nBOB manager los angeles\n" | awk '{
  # Normalize: lowercase everything, then capitalize first field
  lower_line = tolower($0)    # => Entire line to lowercase
  # => "alice engineer new york"
  # => "bob manager los angeles"
 
  # Use toupper on just the first character of $1 for display
  name = toupper(substr($1, 1, 1)) tolower(substr($1, 2))
  # => toupper("A") + tolower("lice") = "Alice" (already mixed)
  # => toupper("B") + tolower("ob")   = "Bob"
 
  print name, tolower($2)   # => Name capitalized, role lowercase
}'
# => Output:
# => Alice engineer
# => Bob manager

printf "Alice 85.3\nBob 92.7\nCarol 71.1\n" | awk '
{
  # Build a formatted label string, store in variable
  label = sprintf("%-10s [%5.1f%%]", $1, $2)
  # => sprintf formats without printing — returns the string
  # => "%-10s" left-pads name to 10 chars
  # => "[%5.1f%%]" formats score with 1 decimal, %% is literal %
 
  # Use the label in further processing
  if ($2 >= 90) {
    print label, "PASS-A"   # => Append status
  } else if ($2 >= 70) {
    print label, "PASS"
  } else {
    print label, "FAIL"
  }
}'
# => Output:
# => Alice      [ 85.3%] PASS
# => Bob        [ 92.7%] PASS-A
# => Carol      [ 71.1%] PASS

printf "Alice\n30\nEngineer\nBob\n25\nManager\n" | awk '
NR % 3 == 1 {
  # => Every 3rd record starting at 1 is a name line
  name = $0           # => Save name from current record
 
  getline age         # => Read next line into "age" variable (not $0)
  # => NR increments, $0 is NOT changed when target variable given
 
  getline role        # => Read next line into "role" variable
  # => NR increments again
 
  printf "Name=%-10s Age=%-5s Role=%s\n", name, age, role
}
'
# => Record 1 (NR=1): "Alice" => name="Alice"
# =>   getline reads NR=2 "30" into age
# =>   getline reads NR=3 "Engineer" into role
# =>   Prints: Name=Alice      Age=30    Role=Engineer
# => Record 4 (NR=4): "Bob" => name="Bob"
# =>   getline reads NR=5 "25" into age
# =>   getline reads NR=6 "Manager" into role
# =>   Prints: Name=Bob        Age=25    Role=Manager
# => Output:
# => Name=Alice      Age=30    Role=Engineer
# => Name=Bob        Age=25    Role=Manager

# Create a lookup file
echo -e "Alice,Engineering\nBob,Marketing\nCarol,Engineering" > /tmp/awk_departments.txt
 
printf "Alice 85\nBob 92\nCarol 71\n" | awk '
BEGIN {
  # Pre-load department lookup from file into array
  while ((getline line < "/tmp/awk_departments.txt") > 0) {
    # => getline returns 1 while lines available, 0 at EOF
    split(line, parts, ",")    # => Split "Alice,Engineering" into parts
    dept[parts[1]] = parts[2]  # => dept["Alice"] = "Engineering"
  }
  close("/tmp/awk_departments.txt")  # => Close file after reading
}
{
  print $1, $2, dept[$1]   # => Lookup department for each name
  # => dept["Alice"] = "Engineering"
  # => dept["Bob"]   = "Marketing"
  # => dept["Carol"] = "Engineering"
}
'
# => Output:
# => Alice 85 Engineering
# => Bob 92 Marketing
# => Carol 71 Engineering
 
rm /tmp/awk_departments.txt

echo "check" | awk '
{
  # Run date command and capture output
  "date +%Y-%m-%d" | getline today    # => Reads one line from date command
  # => today = "2026-04-01" (current date)
 
  "hostname" | getline host           # => Reads hostname
  # => host = "myserver" (or whatever hostname returns)
 
  print "Date:", today
  print "Host:", host
  print "Processing:", $0
}
'
# => Output (date and hostname vary by system):
# => Date: 2026-04-01
# => Host: myserver
# => Processing: check

# Create two temp files
echo -e "alice\nbob" > /tmp/awk_file1.txt
echo -e "carol\ndave" > /tmp/awk_file2.txt
 
awk '{ print FILENAME, NR, FNR, $0 }' /tmp/awk_file1.txt /tmp/awk_file2.txt
# => FILENAME: current input file name
# => NR: total records read so far (across all files)
# => FNR: record number within current file (resets to 1 per file)
# => Output:
# => /tmp/awk_file1.txt 1 1 alice
# => /tmp/awk_file1.txt 2 2 bob
# => /tmp/awk_file2.txt 3 1 carol
# => /tmp/awk_file2.txt 4 2 dave
 
rm /tmp/awk_file1.txt /tmp/awk_file2.txt

echo -e "Alice,Engineering\nBob,Marketing\nCarol,Engineering" > /tmp/awk_depts.txt
echo -e "Alice 85\nBob 92\nCarol 71" > /tmp/awk_scores.txt
 
awk -F'[,\t ]' '
FNR == NR {
  # => Only true while reading the first file (depts.txt)
  # => NR==FNR because both count from same start for first file
  dept[$1] = $2    # => dept["Alice"]="Engineering", etc.
  next             # => Skip to next record, do not fall through
}
{
  # => Executes for second file (scores.txt) only
  print $1, $2, dept[$1]   # => Join score with department
}
' /tmp/awk_depts.txt /tmp/awk_scores.txt
# => First file: load dept["Alice"]="Engineering", dept["Bob"]="Marketing", dept["Carol"]="Engineering"
# => Second file: print Alice 85 Engineering, Bob 92 Marketing, Carol 71 Engineering
# => Output:
# => Alice 85 Engineering
# => Bob 92 Marketing
# => Carol 71 Engineering
 
rm /tmp/awk_depts.txt /tmp/awk_scores.txt

awk 'BEGIN {
  print "ARGC:", ARGC          # => Number of arguments including "awk"
  for (i = 0; i < ARGC; i++) {
    print "ARGV[" i "]:", ARGV[i]
  }
}' /dev/null /dev/null
# => ARGC = 3 (awk + two /dev/null arguments)
# => ARGV[0] = "awk"
# => ARGV[1] = "/dev/null"
# => ARGV[2] = "/dev/null"
# => Output:
# => ARGC: 3
# => ARGV[0]: awk
# => ARGV[1]: /dev/null
# => ARGV[2]: /dev/null

printf "name=Alice;age=30;role=Engineer\nname=Bob;age=25;role=Manager\n" | awk '
BEGIN { RS="\n"; FS=";" }   # => Each line is a record, fields split on ";"
{
  # => Each record is one person's data: "name=Alice;age=30;role=Engineer"
  # => $1="name=Alice", $2="age=30", $3="role=Engineer"
  split($1, n, "="); name = n[2]    # => Extract value after "="
  split($2, a, "="); age  = a[2]
  split($3, r, "="); role = r[2]
  printf "Name=%-10s Age=%-5s Role=%s\n", name, age, role
}
'
# => Output:
# => Name=Alice      Age=30    Role=Engineer
# => Name=Bob        Age=25    Role=Manager

printf "alpha\nbeta\ngamma\ndelta\n" | awk '
BEGIN { ORS=" | " }   # => Join records with " | " instead of newline
{ print $0 }
END { printf "\n" }   # => Add final newline (ORS replaces it otherwise)
'
# => Each "print" appends ORS (" | ") instead of "\n"
# => "alpha" + " | " => "alpha | "
# => "beta"  + " | " => appended: "alpha | beta | "
# => "gamma" + " | " => appended: "alpha | beta | gamma | "
# => "delta" + " | " => appended: "alpha | beta | gamma | delta | "
# => END printf adds final "\n"
# => Output: alpha | beta | gamma | delta |

printf "Alice\nEngineer\nNew York\n\nBob\nManager\nLos Angeles\n\n" | awk '
BEGIN {
  RS=""    # => Paragraph mode: records separated by blank lines
  FS="\n"  # => Fields within each record are newline-separated
}
{
  # => Each record is a blank-line-separated block
  # => $1 = first line = name
  # => $2 = second line = role
  # => $3 = third line = city
  printf "Name=%-10s Role=%-12s City=%s\n", $1, $2, $3
}
'
# => Record 1: $1="Alice", $2="Engineer", $3="New York"
# => Record 2: $1="Bob",   $2="Manager",  $3="Los Angeles"
# => Output:
# => Name=Alice      Role=Engineer     City=New York
# => Name=Bob        Role=Manager      City=Los Angeles

printf "alice@company.com Engineer\nbob@gmail.com Manager\ncarol@company.com Director\n" | awk '
$1 ~ /company\.com/ { print $1, "internal" }
$1 !~ /company\.com/ { print $1, "external" }
# => $1 ~ /company\.com/: does $1 contain "company.com"?
# => \. escapes the dot (literal dot, not "any character" in regex)
'
# => "alice@company.com": matches ~ /company\.com/ => internal
# => "bob@gmail.com":     does NOT match => external
# => "carol@company.com": matches ~ /company\.com/ => internal
# => Output:
# => alice@company.com internal
# => bob@gmail.com external
# => carol@company.com internal

echo "3.14159265358979" | awk '
BEGIN {
  OFMT = "%.4f"       # => 4 decimal places for implicit number output
  CONVFMT = "%.2f"    # => 2 decimal places when converting number to string
}
{
  pi = $1 + 0         # => Force numeric conversion: pi = 3.14159265358979
  print pi            # => Uses OFMT: "3.1416" (4 decimal places, rounded)
 
  s = pi ""           # => Concatenate with empty string => string conversion
  # => Uses CONVFMT: s = "3.14"
  print "As string:", s
  print "Length:", length(s)  # => 4 ("3.14" has 4 chars)
}
'
# => Output:
# => 3.1416
# => As string: 3.14
# => Length: 4

HOME=/tmp DEBUG=1 awk 'BEGIN {
  print "HOME:", ENVIRON["HOME"]      # => "/tmp" (from environment)
  print "DEBUG:", ENVIRON["DEBUG"]    # => "1"
  print "PATH exists:", ("PATH" in ENVIRON)  # => 1 (true, PATH always set)
  print "MISSING:", ENVIRON["NOSUCHVAR"]     # => "" (empty string, not error)
}'
# => ENVIRON holds all shell environment variables
# => Keys that do not exist return "" (empty string)
# => Output:
# => HOME: /tmp
# => DEBUG: 1
# => PATH exists: 1
# => MISSING:

printf "Alice 85\nBob 58\nCarol 92\nDave 74\n" | awk '
{
  status = ($2 >= 70) ? "PASS" : "FAIL"
  # => If $2 >= 70: status = "PASS"; else status = "FAIL"
  # => Alice 85: 85 >= 70 => PASS
  # => Bob 58:   58 < 70  => FAIL
  # => Carol 92: 92 >= 70 => PASS
  # => Dave 74:  74 >= 70 => PASS
 
  marker = ($2 >= 90) ? " ***" : ""
  # => Add marker for scores 90+: Carol gets " ***"
 
  printf "%-10s %3d  %-4s%s\n", $1, $2, status, marker
}'
# => Output:
# => Alice       85  PASS
# => Bob         58  FAIL
# => Carol       92  PASS ***
# => Dave        74  PASS