AWK

AWK
Paradigma	Programación dirixida por eventos, Programación imperativa
Data	1977, última revisión 1985, a versión POSIX actual é IEEE Std 1003.1-2004
Deseñador	Alfred Aho, Peter Weinberger, Brian Kernighan
Tipo de dato	débil, dinámico
Postas en funcionamento	awk, GNU Awk, mawk, nawk, MKS AWK, Thompson AWK (compilador), Awka (compilador)
Dialectos	old awk oawk 1977, new awk nawk 1985, GNU Awk
Influído por	C, Bourne shell, SNOBOL
Influíu	Perl, Korn shell(ksh93, dtksh, tksh), JavaScript
Sistema operativo	Multiplataforma
Web	awk

AWK é unha linguaxe de programación deseñada para procesar datos baseados en texto, xa sexan ficheiros ou fluxos de datos. O nome AWK deriva dos apelidos dos autores: Alfred Aho, Peter Weinberger, e Brian Kernighan. awk, cando está escrito todo en minúsculas, fai referencia ao programa de Unix ou Plan 9 que interpreta programas escritos na linguaxe de programación AWK.

AWK é exemplo dunha linguaxe de programación que usa amplamente o tipo de datos de listas asociativas (é dicir, listas indexadas por cadeas clave), e expresións regulares. O poder, brevidade e limitacións dos programas de AWK inspiraron a Larry Wall a crear outra linguaxe de programación, Perl. Debido á súa densa notación, todas estas linguaxes son frecuentemente usadas para escribir programas dunha liña.

AWK foi unha das primeiras ferramentas en aparecer en Unix (na versión 3) e gañou popularidade como un xeito de engadir funcionalidade ás tubaxes de Unix. A inclusión dalgunha versión da linguaxe AWK é estándar en case todo sistema operativo tipo unix moderno. AWK é mencionado nas Single UNIX Specification (especificacións básicas de unix) como unha das utilidades necesarias de todo sistema operativo Unix. Pódense instalar versións de AWK en case todos os demais sistemas operativos.

Estrutura dos programas AWK

De forma xeral a AWK dánselle dúas pezas de datos: un ficheiro de ordes e un ficheiro primario de entrada. Un ficheiro de ordes (que pode ser un ficheiro real, ou pode ser incluído na invocación de AWK desde a liña de ordes) contén unha serie de ordes que lle din a AWK como procesar o ficheiro de entrada. O ficheiro primario de entrada é normalmente texto formateado dalgún xeito; pode ser nun ficheiro real, ou pode ser lido por AWK da entrada estándar (teclado). Un programa AWK típico consiste nunha serie de liñas, cada unha da forma

/patrón/ { acción }

onde patrón é unha expresión regular e acción é unha orde. A maioría das versións de AWK usan expresións regulares estendidas por defecto. AWK mira ao longo do ficheiro de entrada; cando atopa unha liña que coincide co "patrón", executa a(s) ordes(s) indicadas en acción. As formas alternativas inclúen:

BEGIN { acción }: Executa as ordes acción ao comezo da execución, antes de que os datos comecen a ser procesados.
END { acción }: Similar á forma previa pero executa as ordes acción despois de que todos os datos sexan procesados.
/patrón/: Imprime as liñas acordes ao patrón.
{ acción }: Executa acción por cada liña na entrada.

Cada unha destas formas pode ser incluída varias veces nun arquivo. O ficheiro é procesado de xeito progresivo, entón se houbese dúas declaracións "BEGIN", os seus contidos serán executados en orde de aparición. As declaracións "BEGIN" e "END" non necesitan estar en forma ordenada.

Comandos de AWK

Os comandos de AWK son as declaracións substituídas por acción nos exemplos anteriores. Os comandos de AWK poden incluír chamadas a funcións, asignación de variables, cálculos, ou calquera combinación destas. AWK contén soporte propio para moitas funcións; moitas outras son provistas polas distintas versións de AWK. Ata algunhas versións soportan a inclusión de librerías dinamicamente enlazadas, que poden prover aínda máis funcións.

Por claridade os corchetes ( { } ) serán omitidos nos seguintes exemplos.

O comando print

O comando print é usado para imprimir texto. A forma máis simple deste comando é

print

Isto mostra o contido da liña actualmente procesada. En AWK as liñas son divididas en campos, e estes poden ser operados individualmente:

print: Mostra o contido da liña actual. En AWK, as liñas divídense en campos, e eses campos poden visualizarse de forma separada:
print $1: Mostra o primeiro campo da liña actual
print $1, $3: Mostra o primeiro e terceiro campo da liña actual, separados por unha cadea predefinida, separador de campos de saída ou OFS (polas súas siglas en inglés), cuxo valor predefinido é un carácter de espazo (' ').

Aínda que esta sintaxe ($X) pode suxerir que se traten de variables (o símbolo $ é indicador de variables noutras linguaxes), fan referencia aos campos da liña actual. Un caso especial, sh, refírese á liña enteira. De feito, os comandos "print" e "print sh" resultan similares.

O comando print pode tamén imprimir o resultado de cálculos ou funcións invocadas:

print 3+2
print foobar(3)
print foobar(variable)
print sen(3-2)

A saída pode ser enviada a un arquivo:

print "expresión" > "nome de arquivo"

Variables

Os nomes de variables poden usar calquera combinación dos caracteres [A-Za-z0-9_], coa única excepción das palabras clave da linguaxe. Os operadores + - * / son suma, resta, multiplicación e división respectivamente. Para a concatenación basta con colocar dúas variables (ou cadea constante) xunto a calquera outra, opcionalmente cun espazo intermedio. As cadeas son delimitadas por comiñas dobres. Non é necesario finalizar as instrucións con punto e coma. Pódense engadir comentarios no programa usando # como primeiro carácter nunha liña.

Funcións definidas polo usuario

De xeito similar ao C, a definición de funcións faise con function, o nome da función, os argumentos da función e o corpo da mesma, por exemplo:

function engadir_tres (número, temporal) {    # Os identificadores non conteñen a letra ñ
  temporal = número + 3                       # Tampouco poden ter acentos
  return temporal
}

Podemos invocar a función así:

print engadir_tres(36)     # Imprime 39

As funcións poden ter variables definidas localmente. Os nomes destas son engadidos ao final da lista de argumentos, aínda que os valores destas deben ser omitidos ao chamar a función. É conveniente indentar as variables locais na lista de argumentos para indicar onde terminan os parámetros e onde comezan as variables locais.

Exemplos

Ola mundo

Este é un programa "Ola mundo" moi simple escrito en AWK:

BEGIN { print "Ola mundo!"; exit }

Imprimir liñas maiores a 80 caracteres

Imprime todas as liñas con máis de 80 caracteres. Nótese que a acción por defecto é imprimir a liña actual.

length > 80

Contador de palabras

Conta as palabras na entrada e mostra a cantidade de liñas, palabras e caracteres.

{ w += NF; c += length}
END { print NR, w, c }

Total da primeira columna

Suma os valores da primeira columna dos datos ingresados.

{ s += }
END { print s }

Frecuencia de palabras

Este programa usa listas enlazadas para determinar a cantidade de veces que cada palabra aparece no texto.

BEGIN { FS="[@^a\-zA-Z]+"}

{ for (i=1; i<=NF; i++)
     words[tolower()]++
}

END { for (i in words)
    print i, words[i]
}

Programas autocontidos

Como calquera outra linguaxe de programación, pódense escribir programas AWK autocontidos usando a sintaxe de liñas de shebang.

Por exemplo, un comando UNIX chamado olamundo.awk que imprima o texto "Ola mundo!" podería ser escrito do seguinte xeito:

#!/usr/bin/awk -f
BEGIN { print "Ola mundo!!"; exit }

AWK, versións e implementacións

AWK foi escrito orixinalmente en 1977 para UNIX.

En 1985 os autores comezan a expansión da linguaxe, engadindo funcións definidas polo usuario. A linguaxe é descrita no libro The AWK Programming Language, publicado en 1988. Para evitar confusións coa versión anterior, coa que era incompatible, esta versión coñécese, ás veces, como "novo AWK" ou "nawk". Esta implementación foi publicada baixo unha licenza de software libre en 1996, e segue sendo mantida por Brian Wilson Kernighan.

Algunhas das implementacións máis coñecidas son:

GNU awk, ou gawk, é outra versión libre. Foi escrita antes de que a implementación orixinal fose publicada, e é amplamente utilizada. Case todas as distribucións de linux inclúen unha versión actualizada de gawk e gawk é recoñecido como a implementación estándar no mundo linux. A versión 30 de gawk foi incluída como awk na versión 5.0 de FreeBSD. As versións posteriores de BSD incluíron nawk para evitar o uso das GPL, unhas licenzas de software libre máis restritivas que as BSD no sentido de que un programa publicado baixo a licenza GPL non pode ser modificado para converterse en propietario.
xgawk é un proxecto libre baseado en gawk. Este estende as funcionalidades de gawk para permitirlle o uso de librerías dinámicas.
mawk é unha versión AWK optimizada para ter maior velocidade, escrita por Mike Brennan e baseada nun intérprete bytecode.
Thompson awk ou TAWK é un compilador awk para MS-DOS e Windows, previamente vendido por Thompson Automation Software.
Jawk é un proxecto que engade awk en Java. Engádense extensións para a linguaxe para prover acceso a características de Java dentro dos programas awk (por exemplo, Java threads, sockets, Collections etc).

Digresión

A ave é o emblema de AWK (na cuberta do libro The AWK Programing Language é o Alca).

Véxase tamén

Outros artigos

sed

Bibliografía

Alfred Aho, Brian W. Kernighan, and Peter J. Weinberger (1988). The AWK Programming Language. Addison-Wesley. ISBN 0-201-07981-X. Arquivado dende o orixinal o 20 de abril de 2006. Consultado o 09 de xaneiro de 2008. (en inglés)
Arnold Robbins. Effective awk Programming (Edition 3 ed.). (en inglés)
Arnold Robbins. GAWK: Effective AWK Programming: A User's Guide for GNU Awk (Edition 3 ed.). (en inglés)
Dálle Dougherty, Arnold Robbins (March 1997). sed & awk, Second Edition. O'Reilly Media (Second Edition ed.). ISBN 1-56592-225-5. (en inglés)

Ligazóns externas

Páxina web de GAWK (GNU awk) (en inglés)
Compilador TAWK (en inglés)
Jawk Open Source, unha implementación de AWK en Java (en inglés)
Tutorial de awk en gnulamp (en inglés)