**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 **A**ho, Peter **W**einberger, e Brian **K**ernighan. `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)*

| * v
* c
* e
Linguaxes de programación |
| --- |
| Baixo nivel | 

|  |  |
| --- | --- |
| Primeira xeración | Código máquina |
| Segunda xeración | Assembly |

 |
| Alto nivel | 

|  |  |
| --- | --- |
| Terceira xeración | 
* A+
* ABC
* Algol
* B
* BASIC
* C
* C++
* C#
* COBOL
* CPL
* D
* E
* Fortran
* Go
* Java
* JavaScript
* Lisp
* Objective-C
* PL/1
* Pascal
* Smalltalk
* Visual Basic .NET

 |
| Cuarta xeración | 
* Clarion
* Clipper
* Clojure
* Common Lisp
* Erlang
* GNU Octave
* Haskell
* Lisp
* Lua
* Julia
* Perl
* PHP
* Prolog
* Python
* R
* Ruby
* Rust
* S
* Scilab
* Stata
* SQL

 |
| Quinta xeración | 
* Mercury
* OPS5
* Prolog

 |

 |
| 
* Ambiente de desenvolvemento
* Metaprogramación
* Programación a nivel funcional
* Programación estruturada
* Programación non estruturada
* Programación imperativa
* Programación modular
* Programación multidimensional
* Orientación a obxectos

 |

|  |  |
| --- | --- |
| Control de autoridades | 
* Wd: Q213970
* BNF: 12302957w
* GND: 4242961-4
* LCCN: sh87003812
* MAG: 173540216
* NKC: ph268180
* SUDOC: 031901646

 |