LIBOF

Manuales para la línea de comandos

Man » Manual de awk en línea - documentación en línea detallada para la página de manual de awk

🌍 ☰ 
gawk - lenguaje de escaneo y procesamiento de patrones

SINOPSIS

gawk [ opciones de estilo POSIX o GNU ] -f archivo-de-programa [ -- ] archivo ...
gawk [ opciones de estilo POSIX o GNU ] [ -- ] texto-de-programa archivo ...

LEA PRIMERO

Esta página de manual se proporciona como cortesía. Tenga en cuenta que la Fuente Única de Verdad para gawk es el manual de Texinfo, disponible en línea en varios formatos en https://www.gnu.org/software/gawk/manual. También puede instalarse en el subsistema Info de su sistema y estar disponible a través del comando info(1).

En caso de cualquier contradicción entre el manual de Texinfo y esta página de manual, el manual debe considerarse como la fuente de información definitiva.

DESCRIPCIÓN

Gawk es la implementación del lenguaje de programación AWK del Proyecto GNU. Se ajusta a la definición del lenguaje en el estándar POSIX 1003.1. Esta versión, a su vez, se basa en la descripción de The AWK Programming Language, de Aho, Kernighan y Weinberger. Gawk proporciona las características adicionales que se encuentran en la versión actual de awk de Brian Kernighan y numerosas extensiones específicas de GNU.

La línea de comandos consta de opciones para gawk, el texto del programa AWK (si no se proporciona a través de las opciones -f o --include), y valores que se pondrán a disposición en las variables AWK predefinidas ARGC y ARGV.

Esta página de manual es intencionalmente lo más concisa posible. Los detalles completos se proporcionan en GAWK: Effective AWK Programming, y debe consultarlo para conocer la historia completa de cualquier característica específica. Cuando sea posible, se proporcionan enlaces a la versión en línea del manual.

FORMATO DE OPCIÓN

Las opciones de Gawk pueden ser opciones tradicionales de estilo POSIX de una sola letra o opciones de estilo GNU largas. Las opciones POSIX comienzan con un solo "-", mientras que las opciones largas comienzan con "--". Se proporcionan opciones largas tanto para las características específicas de GNU como para las características requeridas por POSIX.

Las opciones específicas de Gawk se utilizan típicamente en forma de opción larga. Los argumentos para las opciones largas son ya sea que se unen a la opción con un signo "=", sin espacios intermedios, o se pueden proporcionar en el siguiente argumento de la línea de comandos. Las opciones largas se pueden abreviar, siempre que la abreviatura siga siendo única.

Además, cada opción larga tiene una opción corta correspondiente, para que la funcionalidad de la opción se pueda utilizar dentro de scripts ejecutables #!.

OPCIONES

Gawk acepta las siguientes opciones. Primero se enumeran las opciones estándar, seguidas de las opciones para las extensiones de gawk, que se enumeran alfabéticamente por opción corta.

-f archivo-de-programa, --file archivo-de-programa

Lee el código fuente del programa AWK del archivo archivo-de-programa, en lugar del primer argumento de la línea de comandos. Se pueden usar varias opciones -f. Los archivos que se leen con -f se tratan como si comenzaran con una declaración implícita @namespace "awk".

-F fs, --field-separator fs
Utilice fs como separador de campos de entrada (el valor de la variable predefinida FS).

-v var=val, --assign var=val
Asigne el valor val a la variable var, antes de que comience la ejecución del programa. Estos valores de variable están disponibles para la regla BEGIN de un programa AWK.

-b, --characters-as-bytes
Trate todos los datos de entrada como caracteres de un solo byte. La opción --posix anula esta opción.

-c, --traditional
Ejecute en modo de compatibilidad. En modo de compatibilidad, gawk se comporta de forma idéntica a awk de Brian Kernighan; no se reconocen ninguna de las extensiones específicas de GNU.

-C, --copyright
Imprima la versión abreviada del mensaje de información de derechos de autor de GNU en la salida estándar y salga con éxito.

-d[file], --dump-variables[=file]
Imprima una lista ordenada de variables globales, sus tipos y sus valores finales en un archivo. El archivo predeterminado es awkvars.out en el directorio actual.

-D[file], --debug[=file]
Habilite la depuración de programas AWK. Por defecto, el depurador lee los comandos de forma interactiva desde el teclado (entrada estándar). El argumento de archivo opcional especifica un archivo con una lista de comandos para que el depurador los ejecute de forma no interactiva.
En este modo de ejecución, gawk carga el código fuente del programa AWK y luego solicita comandos de depuración. Gawk solo puede depurar el código fuente del programa AWK proporcionado con las opciones -f y --include. El depurador está documentado en GAWK: Effective AWK Programming; consulte https://www.gnu.org/software/gawk/manual/html_node/Debugger.html#Debugger.

-e program-text, --source program-text
Utilice program-text como código fuente del programa AWK. Cada argumento proporcionado a través de -e se trata como si comenzara con una instrucción implícita @namespace "awk".

-E file, --exec file
Similar a -f, sin embargo, esta opción es la última que se procesa. Esto debe utilizarse con scripts #!, particularmente para aplicaciones CGI, para evitar pasar opciones o código fuente en la línea de comandos desde una URL. Esta opción deshabilita las asignaciones de variables de línea de comandos.

-g, --gen-pot
Analice y procese el programa AWK y genere un archivo en formato GNU .pot (Plantilla de objeto portátil) en la salida estándar con entradas para todas las cadenas localizables en el programa. El programa en sí no se ejecuta.

-h, --help
Imprima un resumen relativamente breve de las opciones disponibles en la salida estándar. Según los Estándares de codificación GNU, estas opciones provocan una salida inmediata y exitosa.

-i include-file, --include include-file
Cargue una biblioteca de código fuente awk. Esto busca la biblioteca utilizando la variable de entorno AWKPATH. Si la búsqueda inicial falla, se realizará otro intento después de agregar el sufijo .awk. El archivo se cargará solo una vez (es decir, se eliminan los duplicados), y el código no constituye el código fuente del programa principal. Los archivos leídos con --include se tratan como si comenzaran con una instrucción implícita @namespace "awk".

-I, --trace

Imprime los nombres internos del código de bytes a medida que se ejecutan al ejecutar el programa. El rastreo se imprime en la salida de error estándar. Cada "código de operación" va precedido por un signo + en la salida.

-k, --csv

Habilita el procesamiento especial de CSV. Consulte Comma Separated Values (Valores separados por comas) para obtener más detalles.

-l lib, --load lib
Carga una extensión de gawk desde la biblioteca compartida lib. Esto busca la biblioteca utilizando la variable de entorno AWKLIBPATH. Si la búsqueda inicial falla, se realizará otro intento después de agregar el sufijo de biblioteca compartida predeterminado para la plataforma. Se espera que la rutina de inicialización de la biblioteca se denomine dl_load().

-L [value], --lint[=value]

Proporciona advertencias sobre construcciones que son dudosas o no portables a otras implementaciones de AWK. Consulte https://www.gnu.org/software/gawk/manual/html_node/Options.html#Options para obtener la lista de valores posibles para value.

-M, --bignum

Fuerza la aritmética de precisión arbitraria en los números. Esta opción no tiene efecto si gawk no está compilado para usar las bibliotecas GNU MPFR y GMP. (En este caso, gawk emite una advertencia).

NOTA: Esta función está en período de prueba. El principal mantenedor de gawk ya no la está manteniendo, aunque hay un miembro del equipo de desarrollo que lo está haciendo. Si esta situación cambia, la función se eliminará de gawk.

-n, --non-decimal-data

Reconoce los valores octales y hexadecimales en los datos de entrada. ¡Utilice esta opción con extrema precaución!

-N, --use-lc-numeric

Fuerza a gawk a utilizar el carácter separador decimal de la configuración regional al analizar los datos de entrada.

-o[file], --pretty-print[=file]

Genera una versión con formato de la programa e la envía al archivo. El archivo predeterminado es awkprof.out en el directorio actual. Esta opción implica --no-optimize.

-O, --optimize

Habilita las optimizaciones predeterminadas de gawk en la representación interna del programa. Esta opción está habilitada de forma predeterminada.

-p[prof-file], --profile[=prof-file]

Inicia una sesión de creación de perfiles y envía los datos de creación de perfiles a prof-file. El valor predeterminado es awkprof.out en el directorio actual. El perfil contiene los recuentos de ejecución de cada instrucción del programa en el margen izquierdo y los recuentos de llamadas de función para cada función definida por el usuario. Gawk se ejecuta más lentamente en este modo. Esta opción implica --no-optimize.

-P, --posix

Esto activa el modo de compatibilidad y deshabilita varias extensiones comunes.

-r, --re-interval

Habilita el uso de expresiones de intervalo en la coincidencia de expresiones regulares. Las expresiones de intervalo están habilitadas de forma predeterminada, pero esta opción se mantiene para compatibilidad con versiones anteriores.

-s, --no-optimize

Deshabilita las optimizaciones predeterminadas de gawk en la representación interna del programa.

-S, --sandbox

Ejecuta gawk en modo de sandbox, deshabilitando la función system(), la redirección de entrada con getline, la redirección de salida con print y printf, y la carga de extensiones dinámicas. La ejecución de comandos (a través de canalizaciones) también está deshabilitada.

-t, --lint-old

Proporciona advertencias sobre construcciones que no son compatibles con la versión original de UNIX de awk.

-V, --version

Imprime información de la versión de esta copia específica de gawk en la salida estándar. Esto es útil al informar errores. Según las Normas de Codificación GNU, estas opciones provocan una salida exitosa inmediata.

-- Señala el final de las opciones. Esto es útil para permitir que los argumentos posteriores al programa AWK comiencen con un "-".

En modo de compatibilidad, cualquier otra opción se marca como no válida, pero se ignora. En el funcionamiento normal, siempre que se haya proporcionado texto de programa, las opciones desconocidas se pasan al programa AWK en el array ARGV para su procesamiento.

Para la compatibilidad con POSIX, se puede utilizar la opción -W, seguida del nombre de una opción larga.

EJECUCIÓN DEL PROGRAMA AWK

Un programa AWK consta de una secuencia de directivas opcionales, sentencias de patrón-acción y definiciones de funciones opcionales.

@include "nombre_de_archivo"
@load "nombre_de_archivo"
@namespace "nombre"
patrón { sentencias de acción }
function nombre(lista de parámetros) { sentencias }

Primero, Gawk lee el código fuente del programa desde los archivos de programa especificados, desde los argumentos de --source o desde el primer argumento no opcional en la línea de comandos. Las opciones -f y --source se pueden utilizar varias veces en la línea de comandos. Gawk lee el texto del programa como si todos los archivos de programa y el texto fuente de la línea de comandos se hubieran concatenado.

Además, las líneas que comienzan con @include se pueden utilizar para incluir otros archivos de código fuente en su programa. Esto es equivalente a utilizar la opción --include.

Las líneas que comienzan con @load se pueden utilizar para cargar funciones de extensión en su programa. Esto es equivalente a utilizar la opción --load.

La variable de entorno AWKPATH especifica una ruta de búsqueda que se utilizará al buscar archivos de código fuente con las opciones -f y --include. Si esta variable no existe, la ruta predeterminada es ". : /usr/local/share/awk". (El directorio real puede variar, dependiendo de cómo se haya construido e instalado gawk). Si un nombre de archivo dado a la opción -f contiene un carácter "/", no se realiza ninguna búsqueda de ruta.

La variable de entorno AWKLIBPATH especifica una ruta de búsqueda que se utilizará al buscar archivos de código fuente con la opción --load. Si esta variable no existe, la ruta predeterminada es "/usr/local/lib/gawk". (El directorio real puede variar, dependiendo de cómo se haya construido e instalado gawk).

Gawk ejecuta los programas AWK en el siguiente orden. Primero, se realizan todas las asignaciones de variables especificadas a través de la opción -v. A continuación, gawk compila el programa en una forma interna. Luego, gawk ejecuta el código en las reglas BEGIN (si las hay) y luego procede a leer cada archivo con nombre en el array ARGV (hasta ARGV[ARGC-1]). Si no hay archivos con nombre en la línea de comandos, gawk lee la entrada estándar.

Si un nombre de archivo en la línea de comandos tiene el formato var=val, se trata como una asignación de variable. La variable var se asignará al valor val. (Esto ocurre después de que se hayan ejecutado todas las reglas BEGIN).

Si el valor de un elemento particular de ARGV está vacío (""), gawk lo omite.

Para cada archivo de entrada, si existe una regla BEGINFILE, gawk ejecuta el código asociado antes de procesar el contenido del archivo. De manera similar, gawk ejecuta el código asociado con las reglas ENDFILE después de procesar el archivo.

Para cada registro en la entrada, gawk verifica si coincide con alguno de los patrones en el programa AWK. Para cada patrón con el que el registro coincide, gawk ejecuta la acción asociada. Los patrones se prueban en el orden en que aparecen en el programa.

Finalmente, después de que se agota toda la entrada, gawk ejecuta el código en la(s) regla(s) END (si las hay).

Directorios de la línea de comandos

Según POSIX, los archivos que se especifican en la línea de comandos de awk deben ser archivos de texto. El comportamiento es "indefinido" si no lo son. La mayoría de las versiones de awk tratan un directorio en la línea de comandos como un error fatal.

Para gawk, un directorio en la línea de comandos produce una advertencia, pero de otro modo se omite. Si se proporciona alguna de las opciones --posix o --traditional, gawk vuelve a tratar los directorios en la línea de comandos como un error fatal.

VARIABLES, REGISTROS Y CAMPOS

Las variables de AWK son dinámicas; entran en existencia cuando se utilizan por primera vez. Sus valores son números de punto flotante o cadenas, o ambos, dependiendo de cómo se utilicen. Además, gawk permite que las variables tengan un tipo de expresión regular. AWK también tiene arreglos unidimensionales; se pueden simular arreglos con múltiples dimensiones. Sin embargo, gawk proporciona arreglos de arreglos reales. Se establecen varias variables predefinidas a medida que se ejecuta un programa; estas se describen según sea necesario y se resumen a continuación.

Registros

Normalmente, los registros están separados por caracteres de nueva línea. Puede controlar cómo se separan los registros asignando valores a la variable integrada RS. Consulte [https://www.gnu.org/software/gawk/manual/html_node/Records.html] para obtener más detalles.

Campos

A medida que se lee cada registro de entrada, gawk divide el registro en campos, utilizando el valor de la variable FS como el separador de campos. Además, FIELDWIDTHS y FPAT se pueden utilizar para controlar la división de campos de entrada. Consulte los detalles, a partir de [https://www.gnu.org/software/gawk/manual/html_node/Fields.html].

Cada campo en el registro de entrada se puede hacer referencia por su posición: $1, $2, y así sucesivamente. $0 es todo el registro, incluido el espacio en blanco inicial y final.

La variable NF se establece en el número total de campos en el registro de entrada.

Las referencias a campos inexistentes (es decir, campos después de $NF) producen la cadena nula. Sin embargo, asignar a un campo inexistente (por ejemplo, $(NF+2) = 5) aumenta el valor de NF, crea cualquier campo intermedio con la cadena nula como sus valores y hace que se vuelva a calcular el valor de $0, con los campos separados por el valor de OFS. Las referencias a campos con números negativos producen un error fatal. La disminución de NF hace que se pierdan los valores de los campos posteriores al nuevo valor, y el valor de $0 se vuelve a calcular, con los campos separados por el valor de OFS.

Asignar un valor a un campo existente provoca que se reconstruya todo el registro cuando se hace referencia a $0. De manera similar, asignar un valor a $0 provoca que el registro se vuelva a dividir, creando nuevos valores para los campos.

Valores separados por comas

Cuando se invoca con la opción -k o --csv, gawk no utiliza la determinación de registros ni la división de campos descritas anteriormente. En cambio, los registros terminan con nuevas líneas no entre comillas, y los campos están separados por comas. Se pueden usar comillas dobles para encerrar campos que contienen comas, nuevas líneas o comillas dobles duplicadas. Consulte https://www.gnu.org/software/gawk/manual/html_node/Comma-Separated-Fields.html para obtener más detalles.

Variables integradas

Las variables integradas de Gawk se enumeran a continuación. Esta lista es intencionalmente concisa. Para obtener más detalles, consulte https://www.gnu.org/software/gawk/manual/html_node/Built_002din-Variables.

ARGC        El número de argumentos de la línea de comandos.

ARGIND      El índice en ARGV del archivo actual que se está procesando.

ARGV        Matriz de argumentos de la línea de comandos. La matriz está indexada de 0 a ARGC - 1.

BINMODE     En los sistemas que no son POSIX, especifica el uso del modo "binario" para todas las operaciones de E/S de archivos. Consulte https://www.gnu.org/software/gawk/manual/html_node/PC-Using.html para obtener los detalles.

CONVFMT     El formato de conversión para números, "%.6g" por defecto.

ENVIRON     Una matriz que contiene los valores del entorno actual. La matriz está indexada por las variables de entorno, y cada elemento es el valor de esa variable.

ERRNO       Si se produce un error del sistema al realizar una redirección para getline, durante una lectura para getline o durante un cierre, entonces ERRNO se establece en una cadena que describe el error. El valor está sujeto a la traducción en entornos que no son ingleses.

FIELDWIDTHS Una lista separada por espacios de anchos de campo. Cuando se establece, gawk analiza la entrada en campos de ancho fijo, en lugar de utilizar el valor de la variable FS como separador de campos. Cada ancho de campo puede precederse opcionalmente por un valor separado por dos puntos que especifique el número de caracteres que se van a omitir antes de que comience el campo.

FILENAME    El nombre del archivo de entrada actual. Si no se especifican archivos en la línea de comandos, el valor de FILENAME es "-". Sin embargo, FILENAME no está definido dentro de la regla BEGIN (a menos que se establezca mediante getline).

FNR         El número de registro de entrada en el archivo de entrada actual.

FPAT        Una expresión regular que describe el contenido de los campos en un registro. Cuando se establece, gawk analiza la entrada en campos, donde los campos coinciden con la expresión regular, en lugar de utilizar el valor de FS como separador de campos.

FS          El separador de campos de entrada, un espacio por defecto. Consulte https://www.gnu.org/software/gawk/manual/html_node/Field-Separators.html para obtener más detalles.

FUNCTAB     Una matriz cuyos índices y los valores correspondientes son los nombres de todas las funciones definidas por el usuario o de extensión en el programa. NOTA: no se puede utilizar la instrucción delete con la matriz FUNCTAB.

IGNORECASE  Controla la sensibilidad a mayúsculas y minúsculas de todas las operaciones de expresiones regulares y cadenas. Consulte [https://www.gnu.org/software/gawk/manual/html_node/Case_002dsensitivity.html](https://www.gnu.org/software/gawk/manual/html_node/Case_002dsensitivity.html) para obtener más detalles.

LINT        Proporciona control dinámico de la opción --lint desde dentro de un programa AWK.

NF          El número de campos en el registro de entrada actual.

NR          El número total de registros de entrada vistos hasta el momento.

OFMT        El formato de salida para los números, "%.6g" por defecto.

OFS         El separador de campos de salida, un espacio por defecto.

ORS         El separador de registros de salida, por defecto una nueva línea.

PREC        La precisión de trabajo de los números de punto flotante de precisión arbitraria, 53 por defecto.

PROCINFO    Los elementos de esta matriz proporcionan acceso a la información sobre el programa AWK en ejecución. Consulte [https://www.gnu.org/software/gawk/manual/html_node/Auto_002dset](https://www.gnu.org/software/gawk/manual/html_node/Auto_002dset) para obtener más detalles.

ROUNDMODE   El modo de redondeo que se utilizará para la aritmética de números de precisión arbitraria, por defecto "N" (modo IEEE-754 roundTiesToEven). Consulte [https://www.gnu.org/software/gawk/manual/html_node/Setting-the-rounding-mode](https://www.gnu.org/software/gawk/manual/html_node/Setting-the-rounding-mode) para obtener más detalles.

RS          El separador de registros de entrada, por defecto una nueva línea.

RT          El terminador de registro. Gawk establece RT en el texto de entrada que coincide con el carácter o la expresión regular especificada por RS.

RSTART      El índice del primer carácter que coincide con match(); 0 si no hay coincidencia.

RLENGTH     La longitud de la cadena que coincide con match(); -1 si no hay coincidencia.

SUBSEP      La cadena que se utiliza para separar varios subíndices en los elementos de la matriz, por defecto "\034".

SYMTAB      Una matriz cuyos índices son los nombres de todas las variables y matrices globales definidas actualmente en el programa. No se puede utilizar la instrucción delete con la matriz SYMTAB, ni asignar a elementos con un índice que no sea un nombre de variable.

TEXTDOMAIN  El dominio de texto del programa AWK; se utiliza para encontrar las traducciones localizadas de las cadenas del programa.

Matrices

Las matrices se indexan con una expresión entre corchetes ([ y ]). Si la expresión es una lista de expresiones (expr, expr ...), entonces el subíndice de la matriz es una cadena que consiste en la concatenación del valor (de cadena) de cada expresión, separados por el valor de la variable SUBSEP. Esta función se utiliza para simular matrices multidimensionales. Por ejemplo:

i = "A"; j = "B"; k = "C"
x[i, j, k] = "hello, world\n"

asigna la cadena "hello, world\n" al elemento de la matriz x que está indexado por la cadena "A\034B\034C". Todas las matrices en AWK son asociativas, es decir, se indexan mediante valores de cadena.

El operador especial in se puede utilizar para probar si una matriz tiene un índice que consiste en un valor en particular:

if (val in array)
    print array[val]

Si el array tiene múltiples subíndices, use (i, j) en array.

La construcción in también se puede utilizar en un bucle for para iterar sobre todos los elementos de un array. Sin embargo, la construcción (i, j) in array solo funciona en pruebas, no en bucles for.

Se puede eliminar un elemento de un array utilizando la sentencia delete. La sentencia delete también se puede utilizar para eliminar todo el contenido de un array, simplemente especificando el nombre del array sin un subíndice.

Gawk admite arrays multidimensionales reales. No requiere que tales arrays sean "rectangulares" como en C o C++. Consulte [https://www.gnu.org/software/gawk/manual/html_node/Arrays] para obtener más detalles.

Espacios de nombres

Gawk proporciona una función de espacio de nombres simple para ayudar a solucionar el hecho de que todas las variables en AWK son globales.

Un nombre calificado consta de dos identificadores simples unidos por dos puntos (::). El identificador de la izquierda representa el espacio de nombres y el identificador de la derecha es la variable dentro de él. Todos los nombres simples (no calificados) se consideran que están en el espacio de nombres "actual"; el espacio de nombres predeterminado es awk. Sin embargo, los identificadores simples que consisten únicamente en letras mayúsculas se fuerzan al espacio de nombres awk, incluso si el espacio de nombres actual es diferente.

Puede cambiar el espacio de nombres actual con la directiva @namespace "nombre".

Los nombres de las funciones integradas estándar predefinidas no se pueden utilizar como nombres de espacios de nombres. Los nombres de las funciones adicionales proporcionadas por gawk se pueden utilizar como nombres de espacios de nombres o como identificadores simples en otros espacios de nombres. Para obtener más detalles, consulte [https://www.gnu.org/software/gawk/manual/html_node/Namespaces.html#Namespaces].

Tipos de variables y conversión

Las variables y los campos pueden ser números (de punto flotante), o cadenas, o ambos. También pueden ser expresiones regulares. La forma en que se interpreta el valor de una variable depende de su contexto. Si se utiliza en una expresión numérica, se tratará como un número; si se utiliza como una cadena, se tratará como una cadena.

Para forzar una variable a que se trate como un número, sume cero a ella; para forzarla a que se trate como una cadena, concaténela con la cadena nula.

Las variables no inicializadas tienen el valor numérico cero y el valor de cadena "" (la cadena nula o vacía).

Cuando una cadena debe convertirse en un número, la conversión se realiza utilizando strtod(3). Un número se convierte en una cadena utilizando el valor de CONVFMT como una cadena de formato para sprintf(3), con el valor numérico de la variable como argumento. Sin embargo, aunque todos los números en AWK son de punto flotante, los valores enteros siempre se convierten como enteros.

Gawk realiza las comparaciones de la siguiente manera: si dos variables son numéricas, se comparan numéricamente. Si un valor es numérico y el otro tiene un valor de cadena que es una "cadena numérica", las comparaciones también se realizan numéricamente. De lo contrario, el valor numérico se convierte en una cadena y se realiza una comparación de cadenas. Dos cadenas se comparan, por supuesto, como cadenas.

Tenga en cuenta que las constantes de cadena, como "57", no son cadenas numéricas; son constantes de cadena. La idea de "cadena numérica" solo se aplica a campos, entradas de getline, FILENAME, elementos de ARGV, elementos de ENVIRON y los elementos de una matriz creada por split() o patsplit() que son cadenas numéricas. La idea básica es que solo la entrada del usuario, y solo la entrada del usuario, que parece numérica, debe tratarse como tal.

Constantes octales y hexadecimales

Puede usar constantes octales y hexadecimales de estilo C en el código fuente de su programa AWK. Por ejemplo, el valor octal 011 es igual al decimal 9 y el valor hexadecimal 0x11 es igual al decimal 17.

Constantes de cadena

Las constantes de cadena en AWK son secuencias de caracteres encerradas entre comillas dobles (como "valor"). Dentro de las cadenas, se reconocen ciertas secuencias de escape, como en C. Consulte https://www.gnu.org/software/gawk/manual/html_node/Escape-Sequences para obtener más detalles.

Constantes de expresión regular

Una constante de expresión regular es una secuencia de caracteres encerrada entre barras diagonales (como /valor/).

Las secuencias de escape descritas en el manual también se pueden usar dentro de constantes de expresión regular (por ejemplo, /[ \t\f\n\r\v]/ coincide con los caracteres de espacio en blanco).

Gawk proporciona constantes de expresión regular con tipo estricto. Estas se escriben con un símbolo de barra diagonal inicial (como: @/valor/). Dichas constantes se pueden asignar a escalares (variables, elementos de matriz) y pasar a funciones definidas por el usuario. Las variables a las que se les ha asignado esto tienen tipo de expresión regular.

PATRONES Y ACCIONES

AWK es un lenguaje orientado a líneas. El patrón va primero y luego la acción. Las sentencias de acción están encerradas entre { y }. El patrón o la acción pueden faltar, pero, por supuesto, no ambos. Si falta el patrón, la acción se ejecuta para cada registro de entrada. Una acción que falta es equivalente a

{ print }

que imprime todo el registro.

Los comentarios comienzan con el carácter # y continúan hasta el final de la línea. Se pueden usar líneas en blanco para separar las sentencias. Normalmente, una sentencia termina con un salto de línea, pero este no es el caso de las líneas que terminan con una coma, {, ?, :, && o ||. Las líneas que terminan con do o else también tienen sus sentencias continuadas automáticamente en la línea siguiente. En otros casos, una línea puede continuarse terminándola con una "\", en cuyo caso el salto de línea se ignora. Sin embargo, una "\" después de un # no es especial.

Se pueden colocar varias sentencias en una sola línea separándolas con un ";". Esto se aplica tanto a las sentencias dentro de la parte de acción de un par patrón-acción (el caso habitual) como a las sentencias patrón-acción en sí.

Patrones

Los patrones de AWK pueden ser uno de los siguientes:

BEGIN
END
BEGINFILE
ENDFILE
/expresión regular/
expresión relacional
patrón && patrón
patrón || patrón
patrón ? patrón : patrón
(patrón)
! patrón
patrón1, patrón2

BEGIN y END son dos tipos especiales de patrones que no se prueban con la entrada. Las partes de acción de todos los patrones BEGIN se combinan como si todas las sentencias se hubieran escrito en una única
regla BEGIN. Se ejecutan antes de que se lea alguna de las entradas. De manera similar, todas las reglas END se
combinan y se ejecutan cuando se ha agotado toda la entrada (o cuando se ejecuta una sentencia de salida).
Los patrones BEGIN y END no se pueden combinar con otros patrones en expresiones de patrones. Los patrones BEGIN y
END no pueden tener partes de acción faltantes.

BEGINFILE y ENDFILE son patrones especiales adicionales cuyas acciones se ejecutan antes de leer el
primer registro de cada archivo de entrada de la línea de comandos y después de leer el último registro de cada archivo.

Dentro de la regla BEGINFILE, el valor de ERRNO es una cadena vacía si el archivo se abrió correctamente. De lo contrario, hay algún problema con el archivo y el código debe usar nextfile para omitirlo. Si no se hace esto, gawk produce su error fatal habitual para los archivos que no se pueden abrir.

Para los patrones /expresión regular/, la sentencia asociada se ejecuta para cada registro de entrada
que coincide con la expresión regular. Las expresiones regulares son esencialmente las mismas que las de
egrep(1). Consulte [https://www.gnu.org/software/gawk/manual/html_node/Regexp.html] para obtener más detalles sobre
las expresiones regulares.

Una expresión relacional puede usar cualquiera de los operadores definidos a continuación en la sección sobre acciones.

Estos generalmente prueban si ciertos campos coinciden con ciertas expresiones regulares.

Los operadores &&, || y ! son AND lógico, OR lógico y NOT lógico, respectivamente, como en C. Realizan una evaluación de cortocircuito, también como en C, y se utilizan para combinar patrones más primitivos. Como en la mayoría de los lenguajes, se pueden usar paréntesis para cambiar el orden de evaluación.

El operador ?: es como el mismo operador en C. Si el primer patrón es verdadero, entonces el patrón utilizado para la prueba es el segundo patrón; de lo contrario, es el tercero. Solo se evalúa uno de los segundos y terceros patrones.

La forma pattern1, pattern2 de una expresión se llama patrón de rango. Coincide con todas las entradas, comenzando con un registro que coincide con pattern1, y continuando hasta un registro que coincide con pattern2, inclusive. No se combina con ningún otro tipo de expresión de patrón.

Acciones

Las sentencias de acción están encerradas entre llaves, { y }. Las sentencias de acción consisten en las sentencias de asignación, condicionales y de bucle habituales que se encuentran en la mayoría de los lenguajes. Los operadores, las sentencias de control y las sentencias de entrada/salida disponibles se basan en los de C.

Operadores

Los operadores en AWK, en orden de precedencia descendente, son:

(...) Agrupación

$ Referencia de campo.

++ -- Incremento y decremento, tanto prefijo como sufijo.

^ Exponenciación.

+ - ! Unario más, unario menos y negación lógica.

* / %       Multiplicación, división y módulo.

+ -         Adición y sustracción.

space       Concatenación de cadenas.

|   |&      Entrada/salida canalizada para getline, print y printf.

< > <= >= == !=

Los operadores relacionales estándar.

~ !~        Coincidencia de expresión regular, coincidencia negada.

in          Pertenencia a un array.

&&          AND lógico.

||          OR lógico.

?:          La expresión condicional de C. Tiene la forma expr1 ? expr2 : expr3. Si expr1 es
verdadero, el valor de la expresión es expr2, de lo contrario es expr3. Solo se evalúa una de expr2
y expr3.

= += -= *= /= %= ^=

Asignación. Tanto la asignación absoluta (var = value) como la asignación de operador (las otras formas) son compatibles.

Sentencias de control

Las sentencias de control son las siguientes:

if (condición) sentencia [ else sentencia ]
while (condición) sentencia
do sentencia while (condición)
for (expr1; expr2; expr3) sentencia
for (var in array) sentencia
break
continue
delete array[index]
delete array
exit [ expresión ]
{ sentencias }
switch (expresión) {
case value|regex : sentencia
...
[ default: sentencia ]
}

Sentencias de entrada/salida

Las sentencias de entrada/salida son las siguientes:

close(archivo [, cómo])   Cierra un archivo, canalización o coproceso abierto. El argumento opcional cómo solo debe
utilizarse al cerrar un extremo de una canalización bidireccional a un coproceso. Debe ser un
valor de cadena, ya sea "to" o "from".

getline               Establece $0 a partir del siguiente registro de entrada; establece NF, NR, FNR, RT.

getline <archivo       Establece $0 a partir del siguiente registro del archivo; establece NF, RT.

getline var           Establece var a partir del siguiente registro de entrada; establece NR, FNR, RT.

getline var <archivo     Establece var a partir del siguiente registro del archivo; establece RT.

comando | getline [var]

Ejecuta el comando, canalizando la salida a $0 o var, como se indicó anteriormente, y RT.

comando |& getline [var]

Ejecuta el comando como un coproceso, canalizando la salida a $0 o var, como se indicó anteriormente, y RT. (El comando también puede ser un socket. Consulte la subsección Nombres de archivos especiales, a continuación).

fflush([archivo])        Vacía cualquier búfer asociado con el archivo o canalización de salida abierto. Si
el archivo falta o si es la cadena nula, entonces vacía todos los archivos y canalizaciones de salida
abiertos.

next                  Detiene el procesamiento del registro de entrada actual. Lee el siguiente registro de entrada y
comienza el procesamiento nuevamente con el primer patrón en el programa AWK. Al
llegar al final de los datos de entrada, ejecuta cualquier regla END.

nextfile              Detiene el procesamiento del archivo de entrada actual. El siguiente registro de entrada leído proviene
del siguiente archivo de entrada. Actualiza FILENAME y ARGIND, restablece FNR a 1 y
comienza el procesamiento nuevamente con el primer patrón en el programa AWK. Al
llegar al final de los datos de entrada, ejecuta cualquier regla ENDFILE y END.

print                 Imprime el registro actual. El registro de salida se termina con el
valor de ORS.

print lista-de-expresiones Imprime expresiones. Cada expresión está separada por el valor de OFS. El
registro de salida se termina con el valor de ORS.

print expr-list >file Imprime las expresiones en un archivo. Cada expresión está separada por el
valor de OFS. El registro de salida se termina con el valor de ORS.

printf fmt, expr-list Formatea e imprime.

printf fmt, expr-list >file

Formatea e imprime en un archivo.

system(cmd-line) Ejecuta el comando cmd-line y devuelve el estado de salida. (Esto puede no estar
disponible en sistemas que no sean POSIX). Consulte [https://www.gnu.org/software/gawk/manual/html_node/I_002fO-Functions.html#I_002fO-Functions] para obtener
los detalles completos sobre el estado de salida.

Se permiten redirecciones de salida adicionales para print y printf.

print ... >> file

Añade la salida al archivo.

print ... | command

Escribe en una tubería.

print ... |& command

Envía datos a un coproceso o socket. (Consulte también la subsección Nombres de archivo especiales, a continuación).

La función getline devuelve 1 en caso de éxito, 0 al final del archivo y -1 en caso de error. Si el valor de errno(3) indica que la operación de E/S puede reintentarse, y PROCINFO["input", "RETRY"] está establecido, entonces se devuelve -2 en lugar de -1, y se pueden intentar llamadas adicionales a getline. Tras un error, ERRNO se establece en una cadena que describe el problema.

NOTA: El fallo al abrir un socket bidireccional da como resultado un error no fatal que se devuelve a la
función que llama. Si utiliza una tubería, un coproceso o un socket con getline, o desde print o printf
dentro de un bucle, debe utilizar close() para crear nuevas instancias del comando o del socket. AWK no
cierra automáticamente las tuberías, los sockets o los coprocesos cuando devuelven EOF.

Las versiones de AWK de la instrucción printf y la función sprintf() son similares a las de C. Para obtener más detalles, consulte [https://www.gnu.org/software/gawk/manual/html_node/Printf.html].

Nombres de archivo especiales

Cuando se realiza la redirección de E/S desde print o printf a un archivo, o mediante getline desde un archivo, gawk reconoce internamente ciertos nombres de archivo especiales. Estos nombres de archivo permiten el acceso a los descriptores de archivo abiertos heredados del proceso padre de gawk (normalmente el shell). Estos nombres de archivo también se pueden utilizar en la línea de comandos para nombrar archivos de datos. Los nombres de archivo son:

- El flujo de entrada estándar.

/dev/stdin El flujo de entrada estándar.

/dev/stdout El flujo de salida estándar.

/dev/stderr El flujo de salida de error estándar.

/dev/fd/n El archivo asociado con el descriptor de archivo abierto n.

Los siguientes nombres de archivo especiales se pueden utilizar con el operador de coproceso |& para crear conexiones de red TCP/IP:

/inet/tcp/lport/rhost/rport
/inet4/tcp/lport/rhost/rport
/inet6/tcp/lport/rhost/rport

Archivos para una conexión TCP/IP en el puerto local lport al host remoto rhost en el puerto remoto rport. Utilice un puerto de 0 para que el sistema elija un puerto. Utilice /inet4 para forzar una conexión IPv4 y /inet6 para forzar una conexión IPv6. El uso de /inet utiliza el valor predeterminado del sistema (probablemente IPv4). Solo se puede utilizar con el operador de E/S bidireccional |&.

/inet/udp/lport/rhost/rport
/inet4/udp/lport/rhost/rport
/inet6/udp/lport/rhost/rport

Similar, pero utiliza UDP/IP en lugar de TCP/IP.

Funciones numéricas

AWK tiene las siguientes funciones aritméticas integradas:

atan2(y, x)   Devuelve el arcotangente de y/x en radianes.

cos(expr)     Devuelve el coseno de expr, que está en radianes.

exp(expr)     La función exponencial.

int(expr)     Truncar a entero.

log(expr)     La función logaritmo natural.

rand()        Devuelve un número aleatorio N, entre cero y uno, de tal manera que 0 ≤ N < 1.

sin(expr)     Devuelve el seno de expr, que está en radianes.

sqrt(expr)    Devuelve la raíz cuadrada de expr.

srand([expr]) Usa expr como la nueva semilla para el generador de números aleatorios. Si no se proporciona expr,
usa la hora del día. Devuelve la semilla anterior para el generador de números aleatorios.

Funciones de cadena

Gawk tiene las siguientes funciones de cadena integradas; los detalles se proporcionan en https://www.gnu.org/software/gawk/manual/html_node/String-Functions.

asort(s [, d [, how] ]) Devuelve el número de elementos en la matriz de origen s. Ordena el contenido
de s utilizando las reglas normales de gawk para comparar valores y reemplaza los índices de los valores ordenados de s con enteros secuenciales que comienzan con 1.
Si se especifica la matriz de destino opcional d, primero duplica s en
d y luego ordena d, dejando los índices de la matriz de origen s sin cambios.
La cadena opcional how controla la dirección y el modo de comparación.
Los valores válidos para how se describen en https://www.gnu.org/software/gawk/manual/html_node/String-Functions.html#String-Functions. s y
d pueden ser la misma matriz; esto solo tiene sentido cuando se proporciona el tercer argumento.

asorti(s [, d [, how] ])

Devuelve el número de elementos en la matriz de origen s. El comportamiento es el mismo que el de asort(), excepto que los índices de la matriz se utilizan para ordenar, no los valores de la matriz. Una vez hecho esto, la matriz está indexada numéricamente y los valores son los de los índices originales. Los valores originales se pierden; por lo tanto, proporcione una segunda matriz si desea conservar los originales. El propósito de la cadena opcional how es el mismo que para asort(). Aquí también, s y d pueden ser la misma matriz; esto solo tiene sentido cuando se proporciona el tercer argumento.

gensub(r, s, h [, t])   Busca en la cadena de destino t coincidencias de la expresión regular r. Si h
es una cadena que comienza con g o G, entonces reemplaza todas las coincidencias de r con s.
De lo contrario, h es un número que indica qué coincidencia de r reemplazar. Si t no se proporciona,
use $0 en su lugar. Dentro del texto de reemplazo s, la secuencia \n, donde n es un dígito del 1 al 9, se puede utilizar para indicar solo
el texto que coincidió con la n-ésima subexpresión entre paréntesis. La secuencia
\0 representa todo el texto que coincidió, al igual que el carácter &. A diferencia de
sub() y gsub(), la cadena modificada se devuelve como resultado de la
función y la cadena de destino original no se cambia.

gsub(r, s [, t])        Para cada subcadena que coincida con la expresión regular r en la cadena t,
sustituya la cadena s y devuelva el número de sustituciones. Si no se proporciona t, use $0. Un & en el texto de reemplazo se reemplaza con el
texto que realmente coincidió. Use \& para obtener un & literal. (Esto debe
escribirse como "\\&"; consulte https://www.gnu.org/software/gawk/manual/html_node/Gory-Details.html#Gory-Details para obtener una discusión más completa de
las reglas para los signos de intercalación y las barras diagonales inversas en el texto de reemplazo de
sub(), gsub() y gensub().)

index(s, t)             Devuelve el índice de la cadena t en la cadena s, o cero si t no está
presente. (Esto implica que los índices de los caracteres comienzan en uno).

length([s])             Devuelve la longitud de la cadena s, o la longitud de $0 si no se proporciona s. Con un argumento de matriz, length() devuelve el número de elementos
en la matriz.

match(s, r [, a])       Devuelve la posición en s donde ocurre la expresión regular r, o cero
si r no está presente, y establece los valores de RSTART y RLENGTH. Tenga en cuenta que
el orden de los argumentos es el mismo que para el operador ~: str ~ re. Consulte
https://www.gnu.org/software/gawk/manual/html_node/String-Functions.html#String-Functions para obtener una descripción de cómo se
rellena la matriz a si se proporciona.

patsplit(s, a [, r [, seps] ])
Divide la cadena s en la matriz a y la matriz de separadores seps en la
expresión regular r, y devuelve el número de campos. Los valores de los elementos
son las porciones de s que coincidieron con r. El valor de seps[i] es el separador posiblemente nulo que apareció después de a[i]. El valor de seps[0] es el
separador principal posiblemente nulo. Si se omite r, se utiliza FPAT en su lugar.
Las matrices a y seps se borran primero. Dividir se comporta de forma idéntica
a la división de campos con FPAT.

split(s, a [, r [, seps] ])
Divide la cadena s en la matriz a y la matriz de separadores seps en la
expresión regular r, y devuelve el número de campos. Si se omite r,
se utiliza FS en su lugar. Las matrices a y seps se borran primero. seps[i] es
el separador de campo que coincide con r entre a[i] y a[i+1]. Dividir se comporta de forma idéntica a la división de campos.

sprintf(fmt, expr-list) Imprime expr-list según fmt y devuelve la cadena resultante.

strtonum(str)           Examina str y devuelve su valor numérico. Si str comienza con un 0 inicial, trátelo como un número octal. Si str comienza con un 0x o 0X inicial,
trátelo como un número hexadecimal. De lo contrario, asuma que es un número decimal.

sub(r, s [, t])         Al igual que gsub(), pero reemplace solo la primera subcadena que coincida. Devuelva
cero o uno.

substr(s, i [, n])      Devuelve la subcadena de s de longitud como máximo n, que comienza en i. Si se omite n, use el resto de s.

tolower(str)            Devuelve una copia de la cadena str, con todos los caracteres en mayúsculas en str
traducidos a sus correspondientes minúsculas. Los caracteres que no son alfabéticos
permanecen sin cambios.

toupper(str)            Devuelve una copia de la cadena str, con todos los caracteres en minúsculas en str
traducidos a sus correspondientes mayúsculas. Los caracteres que no son alfabéticos
permanecen sin cambios.

Gawk es compatible con multibyte. Esto significa que index(), length(), substr() y match() funcionan en términos de caracteres, no de bytes.

Funciones de tiempo

Gawk proporciona las siguientes funciones para obtener marcas de tiempo y formatearlas. Los detalles se proporcionan en https://www.gnu.org/software/gawk/manual/html_node/Time-Functions.

mktime(datespec [, utc-flag])

Convierte datespec en una marca de tiempo del mismo formato que la que devuelve systime() y devuelve el resultado. Si utc-flag está presente y es distinto de cero o nulo, se supone que la hora está en la zona horaria UTC; de lo contrario, se supone que la hora está en la zona horaria local. Si datespec no contiene suficientes elementos o si el tiempo resultante está fuera de rango, mktime() devuelve -1. Consulte https://www.gnu.org/software/gawk/manual/html_node/Time-Functions.html#Time-Functions para obtener los detalles de datespec.

strftime([format [, timestamp[, utc-flag]]])

Formatea timestamp según la especificación en format. Si utc-flag está presente y es distinto de cero o nulo, el resultado está en UTC; de lo contrario, el resultado está en la hora local. El timestamp debe tener el mismo formato que el que devuelve systime(). Si falta timestamp, se utiliza la hora actual. Si falta format, se utiliza un formato predeterminado equivalente a la salida de date(1). El formato predeterminado está disponible en PROCINFO["strftime"]. Consulte la especificación de la función strftime() en ISO C para obtener las conversiones de formato que se garantiza que estarán disponibles.

systime() Devuelve la hora actual del día como el número de segundos desde la época (1970-01-01 0000:00 UTC en los sistemas POSIX).

Funciones de manipulación de bits

Gawk proporciona las siguientes funciones de manipulación de bits. Funcionan convirtiendo los valores de punto flotante de doble precisión en enteros uintmax_t, realizando la operación y luego convirtiendo el resultado de nuevo a punto flotante. Pasar operandos negativos a cualquiera de estas funciones provoca un error fatal.

Las funciones son:

and(v1, v2 [, ...]) Devuelve el AND bit a bit de los valores proporcionados en la lista de argumentos. Debe haber al menos dos.

compl(val) Devuelve el complemento bit a bit de val.

lshift(val, count) Devuelve el valor de val, desplazado a la izquierda en count bits.

or(v1, v2 [, ...]) Devuelve el OR bit a bit de los valores proporcionados en la lista de argumentos. Debe haber al menos dos.

rshift(val, count) Devuelve el valor de val, desplazado a la derecha en count bits.

xor(v1, v2 [, ...]) Devuelve el XOR bit a bit de los valores proporcionados en la lista de argumentos. Debe haber al menos dos.

Funciones de tipo

Las siguientes funciones proporcionan información relacionada con el tipo de sus argumentos.

isarray(x) Devuelve verdadero si x es un array, falso en caso contrario.

typeof(x) Devuelve una cadena que indica el tipo de x. La cadena será uno de "array", "number", "regexp", "string", "strnum", "unassigned" o "undefined".

Funciones de internacionalización

Las siguientes funciones se pueden utilizar dentro de su programa AWK para traducir cadenas en tiempo de ejecución. Para obtener más detalles, consulte https://www.gnu.org/software/gawk/manual/html_node/I18N-Functions.html#I18N-Functions.

bindtextdomain(directorio [, dominio])

Especifica el directorio donde gawk busca los archivos .gmo, en caso de que no se puedan colocar en las ubicaciones "estándar". Devuelve el directorio donde se "vincula" el dominio. El dominio predeterminado es el valor de TEXTDOMAIN. Si el directorio es una cadena nula (""), entonces bindtextdomain() devuelve el enlace actual para el dominio dado.

dcgettext(cadena [, dominio [, categoría]])
Devuelve la traducción de la cadena en el dominio de texto dominio para la categoría de idioma categoría. El valor predeterminado para dominio es el valor actual de TEXTDOMAIN. El valor predeterminado para categoría es "LC_MESSAGES".

dcngettext(cadena1, cadena2, número [, dominio [, categoría]])
Devuelve la forma plural utilizada para el número de la traducción de cadena1 y cadena2 en el dominio de texto dominio para la categoría de idioma categoría. El valor predeterminado para dominio es el valor actual de TEXTDOMAIN. El valor predeterminado para categoría es "LC_MESSAGES".

Funciones de valor booleano

Puede crear valores especiales de tipo booleano; consulte el manual para obtener información sobre cómo funcionan y por qué existen.

mkbool(expresión)

Según el valor booleano de la expresión, devuelve un valor verdadero o un valor falso. Los valores verdaderos tienen un valor numérico de uno. Los valores falsos tienen un valor numérico de cero.

FUNCIONES DEFINIDAS POR EL USUARIO

Las funciones en AWK se definen de la siguiente manera:

function nombre(lista de parámetros) { declaraciones }

Las funciones se ejecutan cuando se llaman desde expresiones en patrones o acciones. Los parámetros reales suministrados en la llamada a la función se utilizan para instanciar los parámetros formales declarados en la función. Los arreglos se pasan por referencia, las demás variables se pasan por valor.

Las variables locales se declaran como parámetros adicionales en la lista de parámetros. La convención es separar las variables locales de los parámetros reales mediante espacios adicionales en la lista de parámetros. Por ejemplo:

function f(p, q,     a, b)   # a y b son locales
{
...
}

/abc/     { ... ; f(1, 2) ; ... }

El paréntesis izquierdo en una llamada a la función debe seguir inmediatamente al nombre de la función, sin ningún espacio intermedio. Esta restricción no se aplica a las funciones integradas que se enumeran anteriormente.

Las funciones pueden llamarse entre sí y pueden ser recursivas. Los parámetros de función utilizados como variables locales se inicializan a la cadena nula y al número cero cuando se invoca la función.

Utilice return expr para devolver un valor desde una función. El valor de retorno no está definido si no se proporciona ningún valor, o si la función se devuelve "simplemente al final".

Las funciones se pueden llamar indirectamente. Para hacer esto, asigne el nombre de la función que se va a llamar, como una cadena, a una variable. Luego, utilice la variable como si fuera el nombre de una función, con el prefijo @, de la siguiente manera: function myfunc() { print "myfunc called" ... }

{    ...
the_func = "myfunc"
@the_func()    # llamada a través de the_func a myfunc
...
}

Si se proporciona la opción --lint, gawk advierte sobre las llamadas a funciones no definidas en el momento del análisis, en lugar de en el tiempo de ejecución. Llamar a una función no definida en tiempo de ejecución es un error fatal.

CARGA DINÁMICA DE NUEVAS FUNCIONES

Puede agregar dinámicamente nuevas funciones escritas en C o C++ al intérprete gawk en ejecución con la instrucción @load. Los detalles completos están más allá del alcance de esta página del manual; consulte https://www.gnu.org/software/gawk/manual/html_node/Dynamic-Extensions.html#Dynamic-Extensions.

SEÑALES

El perfilador de gawk acepta dos señales. SIGUSR1 hace que descargue un perfil y la pila de llamadas de funciones en el archivo de perfil, que es awkprof.out o cualquier archivo especificado con la opción --profile. Luego, continúa ejecutándose. SIGHUP hace que gawk descargue el perfil y la pila de llamadas de funciones y luego salga.

INTERNACIONALIZACIÓN

Las cadenas de texto son secuencias de caracteres encerradas entre comillas dobles. En entornos que no son de habla inglesa, es posible marcar las cadenas en el programa AWK como que requieren traducción al idioma natural local. Dichas cadenas se marcan en el programa AWK con un guion bajo inicial ("_"). Por ejemplo,

gawk 'BEGIN { print "hello, world" }'

siempre imprime hello, world. Pero,

gawk 'BEGIN { print _"hello, world" }'

podría imprimir bonjour, monde en Francia. Consulte https://www.gnu.org/software/gawk/manual/html_node/Internationalization.html#Internationalization para conocer los pasos involucrados en la creación y ejecución de un programa AWK localizable.

EXENSIONES GNU

Gawk tiene un número demasiado grande de extensiones a POSIX awk. Se describen en https://www.gnu.org/software/gawk/manual/html_node/POSIX_002fGNU.html. Todas las extensiones se pueden desactivar invocando gawk con las opciones --traditional o --posix.

VARIABLES DE ENTORNO

La variable de entorno AWKPATH se puede utilizar para proporcionar una lista de directorios que gawk busca cuando busca archivos con nombre mediante las opciones -f, --file, -i y --include, y el directivo @include. Si la búsqueda inicial falla, la ruta se busca nuevamente después de agregar .awk al nombre del archivo.

La variable de entorno AWKLIBPATH se puede utilizar para proporcionar una lista de directorios que gawk busca cuando busca archivos con nombre mediante las opciones -l y --load.

La variable de entorno GAWK_PERSIST_FILE, si está presente, especifica un archivo que se utilizará como almacenamiento de respaldo para la memoria persistente. Consulte GAWK: Effective AWK Programming para obtener más detalles.

La variable de entorno GAWK_READ_TIMEOUT se puede utilizar para especificar un tiempo de espera en milisegundos para leer la entrada desde un terminal, una canalización o una comunicación bidireccional, incluidos los sockets.

Para la conexión a un host remoto a través de un socket, GAWK_SOCK_RETRIES controla el número de reintentos, y GAWK_MSEC_SLEEP el intervalo entre reintentos. El intervalo está en milisegundos. En los sistemas que no admiten usleep(3), el valor se redondea al número entero de segundos más cercano.

Si POSIXLY_CORRECT existe en el entorno, entonces gawk se comporta exactamente como si se hubiera especificado --posix en la línea de comandos. Si se ha especificado --lint, gawk emite un mensaje de advertencia en este sentido.

ESTADO DE SALIDA

Si la instrucción exit se utiliza con un valor, entonces gawk sale con el valor numérico proporcionado.

En caso contrario, si no hubo problemas durante la ejecución, gawk sale con el valor de la constante C EXIT_SUCCESS. Esto suele ser cero.

Si se produce un error, gawk sale con el valor de la constante C EXIT_FAILURE. Esto suele ser uno.

Si gawk sale debido a un error fatal, el estado de salida es 2. En los sistemas que no son POSIX, este valor puede asignarse a EXIT_FAILURE.

INFORMACIÓN DE LA VERSIÓN

Esta página man documenta gawk, versión 5.3.

AUTORES

La versión original de UNIX awk fue diseñada e implementada por Alfred Aho, Peter Weinberger y Brian Kernighan de Bell Laboratories. Ozan Yigit es el actual mantenedor. Brian Kernighan ocasionalmente participa en su desarrollo.

Paul Rubin y Jay Fenlason, de la Free Software Foundation, escribieron gawk para que sea compatible con la versión original de awk distribuida en Seventh Edition UNIX. John Woods contribuyó con varios arreglos de errores. David Trueman, con contribuciones de Arnold Robbins, hizo que gawk fuera compatible con la nueva versión de UNIX awk. Arnold Robbins es el actual mantenedor.

Consulte GAWK: Effective AWK Programming para obtener una lista completa de los colaboradores de gawk y su documentación.

Consulte el archivo README en la distribución de gawk para obtener información actualizada sobre los mantenedores y qué puertos son compatibles actualmente.

INFORMES DE ERRORES Y PREGUNTAS

Si encuentra un error en gawk, utilice el programa gawkbug(1) para informarlo.

Las instrucciones completas para informar de un error se proporcionan en https://www.gnu.org/software/gawk/manual/html_node/Bugs.html. Lea y siga cuidadosamente las instrucciones que se dan allí. Esto facilitará la notificación y resolución de errores para todos los involucrados. De verdad.

Por otro lado, si tiene una pregunta sobre cómo lograr una tarea particular utilizando awk o gawk, envíe un correo electrónico a _ con su solicitud de ayuda.

ERRORES

La opción -F no es necesaria dado el atributo de asignación de variables de la línea de comandos; permanece solo para la compatibilidad con versiones anteriores.

Esta página man es demasiado larga; gawk tiene demasiadas funciones.

VÉASE TAMBIÉN

egrep(1), sed(1), gawkbug(1), printf(3) y strftime(3).

The AWK Programming Language, segunda edición, Alfred V. Aho, Brian W. Kernighan, Peter J. Weinberger, Addison-Wesley, 2023. ISBN 9-780138-269722.

GAWK: Effective AWK Programming, Edición 5.3, se incluye con el código fuente de gawk. La versión actual
de este documento está disponible en línea en https://www.gnu.org/software/gawk/manual.

La documentación de GNU gettext está disponible en línea en https://www.gnu.org/software/gettext.

EJEMPLOS

Imprimir y ordenar los nombres de usuario de todos los usuarios:

BEGIN     { FS = ":" }
{ print $1 | "sort" }

Contar las líneas de un archivo:

{ nlines++ }
END  { print nlines }

Anteponer a cada línea su número en el archivo:

{ print FNR, $0 }

Concatenar y numerar las líneas (una variación sobre el tema):

{ print NR, $0 }

Ejecutar un comando externo para líneas de datos específicas:

tail -f access_log |
awk '/myhome.html/ { system("nmap " $1 ">> logdir/myhome.html") }'

PERMISOS DE COPIA

Copyright © 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2002, 2003, 2004, 2005 2007, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 2024, 2025 Free Software Foundation, Inc.

Se concede permiso para realizar y distribuir copias textuales de esta página del manual, siempre que la notificación de derechos de autor y esta notificación de permiso se conserven en todas las copias.

Se concede permiso para copiar y distribuir versiones modificadas de esta página del manual bajo las condiciones de copia textual, siempre que todo el trabajo derivado resultante se distribuya bajo los términos de una notificación de permiso idéntica a esta.

Se concede permiso para copiar y distribuir traducciones de esta página del manual a otro idioma, bajo las condiciones anteriores para las versiones modificadas, excepto que esta notificación de permiso puede indicarse en una traducción aprobada por la Fundación.