Creare CD - Copertina - Giochi

Articoli

AWK questo sconosciuto

Vi sarà sicuramente capitato di dover estrarre dei dati da files di testo o di effettuare delle modifiche riga per riga, eventualmente condizionate dalla presenza di certi pattern, spesso considerando i dati di input come composti da parole o campi. Se avete frequentemente esigenze di questo tipo AWK è lo strumento che fa per voi. Naturalmente potreste scrivere dei meravigliosi programmi in C per fare ciò che vi serve ma dovreste perdere delle intere giornate per scrivere del codice ad-hoc che poi probabilmente non usereste più, e di solito ci mettereste di meno a fare il lavoro a mano.

Volendo dare una definizione sintetica di AWK lo si può definire come un filtro generico per files di testo basato su pattern-matching e programmabile con un linguaggio molto simile al C ma di utilizzo molto più semplificato. Il nome AWK deriva dalle iniziali dei suoi tre inventori originali, Aho, Weinberger e Kernighan, tutti personaggi abbastanza famosi nel campo della computer-science.

Di AWK ne esistono diverse versioni e implementazioni. Io farò riferimento alla implementazione GNU, detta gawk, che oltre a rispettare lo standard POSIX relativo ad AWK ha come sempre qualche funzionalità in più rispetto alle altre implementazioni commerciali che potete trovare in giro. Il Free Software è sempre il meglio!

L'idea che sta alla base di AWK è quello di elaborare una riga alla volta dei files di input, eseguendo azioni diverse a seconda che la riga stessa soddisfi certe condizioni o contenga certi patterns. I programmi scritti in AWK sono strutturati un po' diversamente rispetto a quelli in linguaggi tradizionali. Non esistono infatti un'inizio e una fine del programma stesso, e non è necessario dichiarare le variabili e gestire tutta la solita trafila dell'I/O e del parsing dei dati. A tutto questo ci pensa automaticamente AWK. Quello che resta da fare al programmatore è solamente specificare come devono essere elaborati i dati di input a seconda dei vari patterns in essi contenuti. Un programma AWK è quindi costituito solamente da una lista di regole composte da un pattern ed una corrispondente azione da eseguire se il pattern è soddisfatto:

  pattern { azione }
  pattern { azione }
  ...

La potenza di AWK rispetto ad altri strumenti simili (grep, sed, cut, ecc.) è la possibilità di definire delle azioni completamente arbitrarie da effettuare sui dati di input utilizzando un vero linguaggio di programmazione, senza tuttavia essere costretti a dover gestire tutte le complicazioni tipiche dei linguaggi tradizionali. Il linguaggio di AWK è inoltre dotato di un ricco insieme di funzioni di base, fra cui quelle per la gestione di pattern matching ed espressioni regolari, e permette di gestire in modo molto semplice stringhe ed array associativi. È infine possibile definire delle proprie funzioni, come in qualsiasi linguaggio di programmazione che si rispetti, ed e' sempre possibile richiamare un programma esterno quando non si è in grado di fare una cosa direttamente con AWK.

Qualche esempio pratico

Supponiamo di voler estrarre da un elenco di nomi e numeri di telefono tutte le righe che contengono il nome MARIO. Possiamo fare cosí:

  cat elenco.txt | awk '/MARIO/ { print }'

  awk '/MARIO/ { print }' file1 file2 file3

  cat elenco.txt | awk '/MARIO/'

Negli esempi precedenti il pattern è costituito dall'espressione regolare racchiusa fra / / mentre l'azione corrispondente è quella racchiusa fra { }. Notate che il pattern oppure l'azione possono essere omessi. Se non specifico il pattern significa che l'azione deve essere eseguita per qualsiasi riga di input, mentre se non specifico l'azione (come nell'ultimo esempio) significa che voglio semplicemente stampare la riga di input, che è stata assegnata automaticamente alla variabile $0. Negli esempi precedenti il programma AWK è stato specificato direttamente nella linea di comando. Ovviamente nel caso di programmi più lunghi di qualche riga ciò non è molto pratico, in tal caso si salva il programma in un file e si specifica ad AWK il nome del file da eseguire:

  echo '/MARIO/ {print $0}' > cerca-mario.awk
  cat elenco.txt | awk -f cerca-mario.awk

  cat /etc/passwd | awk -f ~/crack.awk -f /usr/share/awk/passwd.awk

  #!/usr/bin/awk -f
  # Estrae il From e il Subject da una mail.
  ($1 == "From:")    { print(substr($0,7)) }  # mittente
  ($1 == "Subject:") { print(substr($0,10)) } # soggetto

Altre variabili che vengono settate automaticamente da AWK dopo la lettura di ogni riga sono NF, che contiene il numero di campi del record corrente, NR, che contiene il numero totale di record letti, FILENAME, che contiene il nome del file di input corrente, e molte altre ancora.

Una cosa interessante è che se si modifica il valore di un campo viene modificato anche l'intero record di input contenuto in $0, come si vede dal seguente esempio. La stessa cosa succede se si modifica la variabile NF.

  #!/usr/bin/awk -f
  # Come l'esempio precedente ma in italiano
  ($1 == "From:")    { $1 = "Mittente:"; print }
  ($1 == "Subject:") { $1 = "Argomento:"; print }

  cat /etc/passwd | awk 'BEGIN { FS=":" } ($2 == "*") { print $3,$1 }'

Oltre alla variabile FS, che descrive il separatore dei campi di input, e' possibile settare la variabile OFS che specifica il separatore con cui vengono stampati i campi in output. Posso pertanto riscrivere il file delle password con le virgole al posto dei due punti semplicemente con:

  cat /etc/passwd | awk 'BEGIN { FS=":"; OFS="," } { print }'

Gli esempi che ho illustrato finora vi fanno anche vedere che con pochissime righe di codice è possibile scrivere dei programmi AWK che fanno qualcosa di utile. Provate ora a pensare a quanto codice in C dovreste scrivere per realizzare delle cose simili e capirete perché vi conviene conoscere almeno un po' AWK.

Il linguaggio di programmazione di AWK

Come ho già anticipato l'azione associata a ciascun pattern può essere specificata utilizzando un linguaggio di programmazione simile al C. Se già sapete programmare in C non avrete difficoltà ad usare AWK. Ci sono però alcune differenze sostanziali rispetto al C da tenere presenti. La prima è che in AWK esiste un unico tipo di dato, la stringa ASCII, che viene utilizzato come stringa o come numero a seconda del contesto. La seconda è che non devo dichiarare le variabili del mio programma e che queste assumono dei valori di default (la stringa vuota "" o il numero 0) se vengono referenziate senza essere state inizializzate (vedi l'esempio del totalizzatore che usa la variabile sum senza inizializzarla). Non esistono le strutture o gli array e soprattutto mancano i puntatori e tutte le complicazioni che questi si portano dietro. Un'altra cosa molto comoda di AWK è che si possono concatenare fra loro variabili o costanti semplicemente scrivendoli uno dopo l'altro. Per esempio:

  nome = $1
  cognome = $2
  nominativo = nome " " cognome
  print "Nome e Cognome: " nominativo

Il linguaggio di AWK comprende alcune istruzioni molto potenti per leggere e scrivere da files o da pipes su comandi esterni. Fra queste ricordiamo la printf, il cui uso è molto simile a quello del C:

  printf("Nome e Cognome: %-24s\tEtà: %2d\n", nominativo, eta)

  OFS = "\t"
  print "Nome e Cognome: " nominativo, "Età: " eta

Possiamo ovviamente leggere e scrivere in files esterni:

  outfile = "output.txt"
  print $1,$2 > outfile
  print $1,$2 >> "/tmp/xxx.log"	# notare gli apici attorno al nome
  getline < "input.txt"		# assegna NF, $0 e $1 ... $N
  getline my_var < "input.txt"	# assegna la variabile my_var

  print $0  | "mail -s test " destinatario
  print "." | "mail -s test " destinatario
  close("mail -s test " destinatario)

  "hostname" | getline hostname
  close("hostname")

Gli array associativi

Una cosa molto comoda che non si trova in C e che invece è disponibile in AWK è la possibilità di gestire in modo molto semplice degli array associativi, cioè delle strutture dati in cui posso associare un valore ad una chiave arbitraria e recuperarlo in maniera molto efficiente. Per esempio posso contare quante volte ogni parola compare nei dati di input con il seguente programmino:

  #!/usr/bin/awk -f
  { for (i=1; i<=NF; i++) totale[$i]++ }
  END { for (parola in totale) print parola, totale[parola] }

  if ("chiave" in array) ...

  delete array["pippo"]
  delete array

I patterns

Abbiamo visto che un programma AWK è costituito da una serie di coppie pattern-azione, in cui l'uno o l'altro possono essere omessi. Un pattern può essere costituito da:

/espressione regolare/

il pattern risulta vero per tutte le righe che soddifano l'espressione regolare in questione

espressione

una qualsiasi espressione C risulta vera se il suo risultato finale è diverso da zero e dalla stringa vuota.

BEGIN e END

due particolari pattern che risultano veri rispettivamente all'inizio ed alla fine dei dati di input. Possono essere usati per eseguire delle azioni di inizializzazione o di chiusura del programma.

pattern vuoto

un pattern vuoto, cioè mancante, è soddisfatto da qualsiasi riga di input e pertanto la corrispondente azione viene sempre eseguita, a meno che una delle azioni precedenti decida di saltare al record successivo.

pattern1,pattern2

una coppia di pattern risulta soddisfatta per il gruppo di record compresi fra quello che soddisfa il primo pattern e quello che soddisfa il secondo, estremi inclusi.

Le espressioni regolari

Per spiegare bene le espressioni regolari ci vorrebbe un'intero articolo, pertanto assumo che già le conosciate almeno a grandi linee e cercherò di farvi vedere come si possono usare con AWK.

Posso usare un'espressione regolare per confrontare l'intera riga di input oppure un singolo campo utilizzando l'operatore ~:

  #!/usr/bin/awk -f
  /^From: /       { print "Mittente: " $2 }
  $1 ~ /Subject:/ { $1 = "Soggetto:"; print } 

  if (match($1, /Microsoft/) {
      gsub(/Microsoft/, "Micro$$$oft", $1)
  }

Le funzioni built-in

Il linguaggio di AWK contiene un buon numero di funzioni built-in predefinite, per esempio funzioni numeriche, funzioni per lavorare con stringhe, funzioni di I/O, funzioni per formattare le date, ecc. Fra le più utili possiamo ricordare:

match(string, regexp)

ritorna la posizione nella stringa dove è stato trovato un testo che soddisfa l'espressione regolare.

sub(regexp, repl [,var])

sostituisce il valore repl all'espressione regolare regexp nella variabile var oppure in $0. Esiste anche una gsub che fa la stessa cosa ma per tutte le occorrenze di regexp

substr(stringa, pos [,len])

ritorna la sottostringa a partire dal carattere pos della stringa e lunga al massimo len, se specificato

split(stringa, array [,regexp])

spezza la stringa in una serie di elementi in corrispondenza di una espresssione regolare, li assegna agli elementi dell'array array[1] ... array[N] e restituisce il numero di elementi trovati

system(comando)

esegue un comando unix esterno e restituisce il suo codice di ritorno

Una cosa abbastanza facile da fare con AWK è un filtro che spia tutto quello che viene scritto in un file di log e calcola delle statistiche, o dei totali oppure esegue dei comandi quando trova certi messaggi di errore. Per esempio:

  tail -f /var/log/messages \
  | awk '($5 ~ "rshd" && $7 ~ "root") { system("mail -s 'ROOT RSH' root") }'

Le funzioni definite dall'utente

AWK permette all'utente di definire delle proprie funzioni che possono poi essere utilizzate liberamente all'interno del codice esattamente come quelle predefinite. La sintassi per definire nuove funzioni è la seguente:

  function nome(parametri) {
      ... body ...
  }

  function fact(n) {
      if (n <= 1) {
	  return(1)
      } else {
          return (n * fact(n-1))
      }
  }

  $1 ~ "^[0-9]+$" {
      m = fact($1)
  }

  function fact(n,	var1, var2) {
      var1 = ...
      var2 = ...
      if (n <= 1) {
	  return(1)
      } else {
          return (n * fact(n-1))
      }
  }

Come richiamare AWK

Esistono vari modi di modi di utilizzare AWK, da solo o in combinazione con altri programmi. È possibile eseguirlo semplicemente dal prompt delle shell passandogli lo script nella linea di comando, se non è troppo lungo:

  awk '/pippo/ { print $1 }' input-file.txt

  awk -f pippo.awk input-file.txt

  pippo.awk input-file.txt

  #!/bin/bash
  ...
  find . -name \*.c | awk '
      # programma awk
      BEGIN { ... }
      ($1 == "xyz") { ... }
  ' | sort | uniq
  ...

Alcuni esempi più o meno triviali

AWK viene usato molto di frequente per fare operazioni 'triviali' sui dati di input, cose che spesso potrei fare anche utilizzando cat, grep o sed. Molto spesso si tratta di progammi di una sola riga. Vediamo qualche esempio.

• Stampare ciascuna riga di input (come cat):

  awk '{ print }'
    

• Stampare le righe di input non vuote. In questo esempio c'e' una regola con un pattern ma senza azione, che equivale a { print }

  awk 'NF > 0'
    

• Numerare le righe di input (come cat -n):

  awk '{ print NR, $0 }'
    

• Contare il numero di righe di input (come wc -l):

  awk 'END { print NR }'
    

• Estrarre una colonna di input (simile al cut, ma più furbo). Questo è una cosa che si usa molto spesso negli script per estrarre colonne delimitate da uno o più spazi o tab, cosa che col cut non è possibile fare. Questo è un classico caso in cui il cut non va bene.

  df -k | awk '{ print $4 }'
    

• Estrarre una colonna di input in corrispondenza di una certa chiave. In questo esempio il programma eseguito da awk è una stringa fra doppi apici in cui la variabile $ipaddr è stata sostituita dalla shell mentre i $ preceduti da backslash restano come sono.

  cat /etc/hosts | awk "(\$1 == $ipaddr) { print \$2 }"
    

  oppure

  cat /etc/hosts | awk -v ip=$ipaddr '($1 == $ip) { print $2 }'
    

• Totalizzare una colonna di input. Notare come è possibile settare una variabile del programma dalla linea di comando con lo switch -v e come si possa referenziare un campo di input con il valore contenuto in una variabile. Questo è un altro modo di passare dei valori all'interno di un programma AWK. È preferibile alla tecnica precedente perché non devo usare i backslash per quotare $ e doppi apici.

  awk -v ncol=3 '{ sum += $ncol } END { print sum }'
    

• Cercare il valore massimo di una colonna

  awk '{ if ($1 > max) { max = $1 } } END { print max }'
    

• Estrarre le righe dispari di un file

  awk '(NR % 2) { print }'
    

• Stampare la lunghezza massima delle righe di input

  expand | awk '{ if (max %lt; length()) max = length() } END { print max }'
    

• Calcolare l'occupazione totale su disco di una directory

  ls -l | awk '/^-/ { tot += int(($5+1023)/1024) } END { print tot*1024 }'
    

• Stampare N numeri random fra 0 e 100

  awk -v n=10 'BEGIN { for (i=1; i<=n; i++) print int(101 * rand()); exit }'
    

  #!/usr/bin/gawk -f
  BEGIN {
      ESCAPE = "^["
      inizializzazione()
      show_menu()
      prompt()
  }

  END {
      cls()
      print "Bye."
  }

  ($1 == "q" || $1 == "quit") {
      exit
  }

  ($1 == "1") {
      do_comando1()
      show_menu()
      prompt()
      next
  }

  ...

  {
      show_menu()
      message("\007comando sconosciuto")
      prompt()
      next
  }

  function inizializzazione() {
      ...
  }

  function do_comando1() {
      ...
  }

  function show_menu() {
      cls();
      cursor(2,1); printf("1.\tComando 1")
      ...
  }

  function message(msg) {
      cursor(25,1); kill_line()
      printf msg
  }

  function prompt() {
      cursor(24,1); kill_line()
      printf("comando ==> ")
  }

  function cls() {
      printf(ESCAPE "[2J")
      printf(ESCAPE "[1;1H")
  }

  function cursor(row, col) {
      printf(ESCAPE "[" row ";" col "H")
  }

  function kill_line() {
      printf(ESCAPE "[K")
  }

di Massimo Dal Zotto

Creare CD - Copertina - Giochi