AWK

El comando print se utiliza para imprimir texto. El texto de salida siempre termina con una cadena predefinida llamada separador de registros de salida (ORS), cuyo valor predeterminado es un salto de línea. La forma más sencilla de este comando es:

print

Esto muestra el contenido del registro actual. En AWK, los registros se dividen en campos , y estos se pueden mostrar por separado:

print $1

Muestra el primer campo del registro actual.

print $1, $3

Muestra el primer y el tercer campo del registro actual, separados por una cadena predefinida llamada separador de campo de salida (OFS), cuyo valor predeterminado es un solo espacio.

Aunque estos campos ( $X ) puedan parecerse a variables (el símbolo $ indica variables en los shells Unix habituales y en Perl ), en realidad se refieren a los campos del registro actual. Un caso especial, $0 , se refiere al registro completo. De hecho, los comandos " print" y " print $0" tienen la misma funcionalidad.

El comando print también puede mostrar los resultados de cálculos y/o llamadas a funciones:

/regex_pattern/ { # Acciones a realizar en caso de que el registro (línea) coincida con el patrón regex_pattern anterior print 3 + 2 print foobar ( 3 ) print foobar ( variable ) print sin ( 3 - 2 ) }

La salida puede enviarse a un archivo:

/regex_pattern/ { # Acciones a realizar en caso de que el registro (línea) coincida con el patrón regex_pattern anterior print "expresión" > "nombre de archivo" }

o a través de una tubería :

/regex_pattern/ { # Acciones a realizar en caso de que el registro (línea) coincida con el patrón regex_pattern anterior print "expresión" | "comando" }

Las variables integradas de AWK incluyen las variables de campo: $1, $2, $3, etc. ($0 representa el registro completo). Estas variables almacenan el texto o los valores de los campos de texto individuales de un registro.

Otras variables incluyen:

• NR: Número de registros. Mantiene un recuento actual del número de registros de entrada leídos hasta el momento de todos los archivos de datos. Comienza en cero, pero nunca se reinicia automáticamente a cero. ^{[ 15 ]}
• FNR: Número de registros del archivo. Mantiene un recuento actual del número de registros de entrada leídos hasta el momento en el archivo actual. Esta variable se restablece automáticamente a cero cada vez que se inicia un nuevo archivo. ^{[ 15 ]}
• NF: Número de campos. Contiene el número de campos en el registro de entrada actual. El último campo del registro de entrada se puede designar con $NF, el penúltimo con $(NF-1), el antepenúltimo con $(NF-2), etc.
• FILENAME: Contiene el nombre del archivo de entrada actual.
• FS: Separador de campos. Contiene el separador de campos que se utiliza para dividir los campos en el registro de entrada. El valor predeterminado, "espacio en blanco", permite cualquier secuencia de espacios y tabulaciones. Se puede reasignar el separador de campos con otro carácter o secuencia de caracteres.
• RS: Separador de registros. Almacena el carácter "separador de registros" actual. Dado que, por defecto, una línea de entrada es el registro de entrada, el carácter separador de registros predeterminado es un "salto de línea".
• OFS: Separador de campos de salida. Almacena el "separador de campos de salida", que separa los campos cuando awk los imprime. El valor predeterminado es un espacio.
• ORS: Separador de registros de salida. Almacena el "separador de registros de salida", que separa los registros de salida cuando awk los imprime. El valor predeterminado es un carácter de "salto de línea".
• OFMT: Formato de salida. Almacena el formato para la salida numérica. El formato predeterminado es "%.6g".

Con excepción de las palabras clave del lenguaje, los nombres de las variables pueden usar cualquiera de estos caracteres siempre que no comience con un dígito numérico  :

[ a - zA - Z_0 - 9 ]

Los operadores +-*/^%representan suma, resta, multiplicación, división, potenciación y resto, respectivamente. Para la división y el resto, se aplican los mismos operadores tanto a divisiones de enteros como de punto flotante. Para obtener un cociente entero a partir de operandos enteros, cualquier resto debe restarse previamente del dividendo, como se muestra a continuación  :

awk​COMIENZO { OFMT = "%.14g"imprimir 331 % - 79imprimir - 3,31e-11 % 7,9e-23impresión 331 / 79imprimir ( 331 - 331 % 79 ) / 79} '15- 1.1999020635259e-234.18987341772154

Este int( dividend / divisor )enfoque puede generar casos límite que redondean incorrectamente. Para la concatenación de cadenas , simplemente coloque dos variables (o constantes de cadena) una al lado de la otra. Es opcional usar un espacio entre ellas si se trata de constantes de cadena, pero dos nombres de variables colocados uno al lado del otro requieren un espacio entre ellos. A diferencia de los shells de Unix u otros lenguajes como Perl, el nombre de variable de un solo guion bajo sin sigilo ( _) no está reservado ni es especial, y el usuario puede utilizarlo libremente. Dado que su valor predeterminado es el valor NULL especial de AWK que es simultáneamente cero numérico y la cadena vacía, incluso podría imitar el de Perl $_como un alias para $0 :

jot 30 | perl - nle ' print $_ << $_ ' | awk ' { print 2 ^ $_ * $_ } '

Las comillas dobles ( "..."), y solo las comillas dobles, delimitan las constantes de cadena. Las sentencias y/o expresiones no necesitan terminar con punto y coma. De hecho, el único lugar donde el punto y coma ;es absolutamente inevitable es la variante de 3 argumentos del for ()bucle que se asemeja mucho a su contraparte en C/C++. Todos los argumentos que no son matrices a las funciones se pasan "por valor", lo que permite que la función los mute libremente y garantiza que no haya efectos secundarios para quien llama a la función.

A diferencia de Python, todas las asignaciones aumentadas en awkeste lenguaje +=-=*=/=^=%=son expresiones. Esto permite un encadenamiento efectivo de longitud ilimitada. Una de sus mayores ventajas se demuestra con el algoritmo para calcular los números de Fibonacci, cuya complejidad es de , O(n) debido a que se sigue sumando a sí mismo: a += b += a += b += a += b += ... Para los primeros 77 números de Fibonacci, aproximadamente, este enfoque es muy efectivo, ya que evita tener que examinar bits, intercambiar variables o incurrir en la sobrecarga de la recursión.

Finalmente, se pueden agregar comentarios a los programas utilizando #como primer carácter en una línea, o después de un comando o secuencia de comandos.

En un formato similar al de C , las definiciones de funciones constan de la palabra clave function, el nombre de la función, los nombres de los argumentos y el cuerpo de la función. Aquí hay un ejemplo de una función.

función agregar_tres ( número ) { devolver número + 3 }

Esta instrucción se puede invocar de la siguiente manera:

( patrón ) { imprimir add_three ( 36 ) # Salida '''39''' }

Las funciones pueden tener variables de ámbito local. Los nombres de estas variables se añaden al final de la lista de argumentos, aunque sus valores deben omitirse al llamar a la función. Por convención, se añade un espacio en blanco en la lista de argumentos antes de las variables locales para indicar dónde terminan los parámetros y dónde comienzan las variables locales.

Aquí está el programa habitual "¡Hola, mundo!" escrito en AWK:

INICIO { imprimir "¡Hola, mundo!" salir }

Imprime todas las líneas de más de 80 caracteres. La acción predeterminada es imprimir la línea actual.

longitud ( $ 0 ) > 80

Cuenta las palabras en la entrada e imprime el número de líneas, palabras y caracteres (como wc ):

{ palabras += NF caracteres += longitud + 1 # se suma uno para tener en cuenta el carácter de nueva línea al final de cada registro (línea) } FIN { imprimir NR , palabras , caracteres }

Como no hay un patrón para la primera línea del programa, cada línea de entrada coincide por defecto, por lo que las acciones de incremento se ejecutan para cada línea. words += NFes una abreviatura de words = words + NF.

{ s += $ NF } FIN { imprimir s + 0 }

sse incrementa por el valor numérico de $NF, que es la última palabra de la línea según lo define el separador de campos de AWK (por defecto, espacio en blanco). NFes el número de campos en la línea actual, por ejemplo, 4. Dado que $4es el valor del cuarto campo, $NFes el valor del último campo de la línea, independientemente de cuántos campos tenga esta línea, o si tiene más o menos campos que las líneas circundantes. $es en realidad un operador unario con la mayor precedencia de operador . (Si la línea no tiene campos, entonces NFes 0, $0es la línea completa, que en este caso está vacía salvo por posibles espacios en blanco, y por lo tanto tiene el valor numérico 0).

Al final de la entrada, el ENDpatrón coincide, por lo que sse imprime. Sin embargo, dado que puede que no haya habido ninguna línea de entrada, en cuyo caso nunca se ha asignado ningún valor a s, sserá una cadena vacía por defecto. Agregar cero a una variable es un modismo de AWK para convertirla de una cadena a un valor numérico. Esto resulta de los operadores aritméticos de AWK, como la suma, que convierten implícitamente sus operandos a números antes del cálculo según sea necesario. (De manera similar, concatenar una variable con una cadena vacía la convierte de un número a una cadena, por ejemplo, s "". Tenga en cuenta que no hay un operador para concatenar cadenas, simplemente se colocan adyacentes). En una entrada vacía, la conversión en { print s + 0 }hace que el programa imprima 0, mientras que con solo la acción { print s }, se imprimiría una línea vacía.

NR % 4 == 1 , NR % 4 == 3 { printf "%6d %s\n" , NR , $ 0 }

La instrucción de acción imprime cada línea numerada. La función printf emula la función printf estándar de C y funciona de manera similar al comando print descrito anteriormente. Sin embargo, el patrón de coincidencia funciona de la siguiente manera: NR es el número de registros, normalmente líneas de entrada, que AWK ha leído hasta el momento, es decir, el número de línea actual, comenzando en 1 para la primera línea de entrada. % es el operador módulo . NR  % 4 == 1 es verdadero para la 1.ª, 5.ª, 9.ª, etc., línea de entrada. Del mismo modo, NR  % 4 == 3 es verdadero para la 3.ª, 7.ª, 11.ª, etc., línea de entrada. El patrón de rango es falso hasta que la primera parte coincide, en la línea 1, y luego permanece verdadero hasta que la segunda parte coincide, en la línea 3 inclusive. Luego permanece falso hasta que la primera parte coincide de nuevo en la línea 5.

Así, el programa imprime las líneas 1, 2 y 3, omite la línea 4, y luego las líneas 5, 6 y 7, y así sucesivamente. Para cada línea, imprime el número de línea (en un campo de 6 caracteres de ancho) y luego el contenido de la línea. Por ejemplo, cuando se ejecuta con esta entrada:

Roma Florencia Milán Nápoles Turín Venecia

El programa anterior imprime:

 1 Roma 2 Florencia 3 Milán 5 Turín 6 Venecia

/^--cortar aquí--$/ , 0

Frecuencia de palabras mediante matrices asociativas :

INICIO { FS = "[^a-zA-Z]+" } { para ( i = 1 ; i <= NF ; i ++ ) palabras [ tolower ( $ i )] ++ } FIN { para ( i en palabras ) imprimir i , palabras [ i ] }

El bloque BEGIN establece el separador de campos a cualquier secuencia de caracteres no alfabéticos. Los separadores pueden ser expresiones regulares. Después, llegamos a una acción simple, que realiza la acción en cada línea de entrada. En este caso, para cada campo en la línea, sumamos uno al número de veces que aparece esa palabra, primero convertida a minúsculas. Finalmente, en el bloque END, imprimimos las palabras con sus frecuencias. La línea

para (i en palabras)

crea un bucle que recorre el array `words` , asignando `i` a cada subíndice del array. Esto difiere de la mayoría de los lenguajes, donde un bucle similar recorre cada valor del array. El bucle imprime cada palabra seguida de su frecuencia de aparición. Esta funcionalidad tolowerse añadió a la versión "One True" de `awk` (véase más abajo) después de la publicación del libro.

Este programa se puede representar de varias maneras. La primera utiliza el intérprete de comandos Bourne para crear un script que lo haga todo. Es el método más corto:

#!/bin/shpatrón = " $1 " shift awk '/' " $pattern " '/ { print FILENAME ":" $0 }' " $@ "

El $patternen el comando awk no está protegido por comillas simples, por lo que el shell expande la variable, pero necesita ponerse entre comillas dobles para manejar correctamente los patrones que contienen espacios. Un patrón por sí solo de la forma habitual comprueba si toda la línea ( $0) coincide. FILENAMEcontiene el nombre del archivo actual. awk no tiene un operador de concatenación explícito; dos cadenas adyacentes las concatenan. $0se expande a la línea de entrada original sin cambios.

Hay formas alternativas de escribir esto. Este script de shell accede al entorno directamente desde dentro de awk:

#!/bin/shexport pattern = " $1 " shift awk '$0 ~ ENVIRON["pattern"] { print FILENAME ":" $0 }' " $@ "

Este es un script de shell que utiliza ENVIRONun array introducido en una versión más reciente de awk (One True) después de la publicación del libro. El subíndice de ENVIRONes el nombre de una variable de entorno; su resultado es el valor de la variable. Esto es similar a la función getenv en varias bibliotecas estándar y POSIX . El script de shell crea una variable de entorno patternque contiene el primer argumento, luego elimina ese argumento y hace que awk busque el patrón en cada archivo.

~Comprueba si su operando izquierdo coincide con su operando derecho; !~es su inverso. Una expresión regular es simplemente una cadena de caracteres y puede almacenarse en variables.

La siguiente forma utiliza la asignación de variables de línea de comandos, en la que un argumento de awk puede verse como una asignación a una variable:

#!/bin/shpatrón = " $1 " shift awk '$0 ~ patrón { print FILENAME ":" $0 }' patrón = " $pattern " " $@ "

O bien, puede utilizar la opción de línea de comandos -v var=valor (por ejemplo , awk -v patrón="$patrón" ... ).

Finalmente, esto está escrito en awk puro, sin ayuda de un shell ni necesidad de saber demasiado sobre la implementación del script awk (como ocurre con la asignación de variables en la línea de comandos), pero es un poco extenso:

BEGIN { patrón = ARGV [ 1 ] para ( i = 1 ; i < ARGC ; i ++ ) # eliminar el primer argumento ARGV [ i ] = ARGV [ i + 1 ] ARGC -- si ( ARGC == 1 ) { # el patrón era lo único, así que forzar la lectura desde la entrada estándar (usada por el libro) ARGC = 2 ARGV [ 1 ] = "-" } } $ 0 ~ patrón { imprimir NOMBRE DE ARCHIVO ":" $ 0 }

Es BEGINnecesario no solo extraer el primer argumento, sino también evitar que se interprete como un nombre de archivo después de que BEGINtermine el bloque. ARGC, el número de argumentos, siempre se garantiza que sea ≥1, al igual que ARGV[0]es el nombre del comando que ejecutó el script, generalmente la cadena "awk". ARGV[ARGC]es la cadena vacía, "". #inicia un comentario que se expande hasta el final de la línea.

Observe el ifbloque. awk solo comprueba si debe leer desde la entrada estándar antes de ejecutar el comando. Esto significa que

awk 'prog'

Solo funciona porque el hecho de que no haya nombres de archivo se comprueba antes progde ejecutarse. Si lo estableces explícitamente ARGCen 1 para que no haya argumentos, awk simplemente se detendrá porque considera que no hay más archivos de entrada. Por lo tanto, debes indicar explícitamente que lea desde la entrada estándar con el nombre de archivo especial -.