Registros, campos y separadores personalizados en awk

awk lee la entrada línea por línea. Cada línea se denomina registro, y cada fragmento separado por espacios en blanco dentro de esa línea se denomina campo.

• $0: el registro actual completo (toda la línea)
• $1: el primer campo
• $2: el segundo campo
• $NF: el último campo (NF = número de campos)

De forma predeterminada, awk separa los campos en cualquier secuencia de espacios en blanco (espacios o tabulaciones). Esto lo hace útil de inmediato para analizar registros, salidas de comandos y datos delimitados por espacios.

La variable integrada FS (separador de campos) indica a awk cómo dividir cada registro en campos. Su valor predeterminado es un espacio simple, que activa el modo de separación por espacios en blanco.

Puede establecer FS de dos formas:

• Con la opción -F en la línea de comandos: awk -F':'
• Dentro de un bloque BEGIN: BEGIN { FS = ":" }

Ambas formas son equivalentes. El enfoque del bloque BEGIN se prefiere en scripts largos porque mantiene la configuración dentro del propio script, lo que mejora su legibilidad y portabilidad.

En scripts de más de una línea, colocar FS dentro de un bloque BEGIN es la práctica habitual. El bloque BEGIN se ejecuta antes de que awk lea cualquier entrada, por lo que el separador está listo para el primer registro.

Este patrón también permite establecer varias variables a la vez, añadir comentarios y mantener la lógica encapsulada en un archivo de script.

Separadores habituales que encontrará en la práctica:

• Dos puntos :: /etc/passwd, /etc/shadow
• Tabulación \t: exportaciones TSV, salida de compiladores
• Coma ,: archivos CSV (simples, sin campos entrecomillados)
• Barra vertical |: algunos formatos de registro, volcados de bases de datos

CSV (valores separados por comas) es uno de los formatos de datos más habituales en la ingeniería de shell. Establecer FS="," permite que awk trate las comas como delimitadores.

Advertencia importante: el manejo de CSV integrado en awk no tiene en cuenta los campos entrecomillados que contienen comas (por ejemplo, "Smith, John"). Para CSV simples sin comas entrecomilladas, funciona perfectamente. Para archivos CSV conformes con RFC 4180 y con campos entrecomillados, use un analizador CSV específico o miller/csvkit.

Una tarea habitual en la práctica es extraer columnas concretas y filtrar filas por valor; ambas operaciones son triviales con awk una vez establecido FS.

El FS de awk no está limitado a un solo carácter: puede ser una expresión regular. Esto resulta muy potente para formatos de registros reales cuyos campos están separados por delimitadores de longitud variable.

Ejemplos de separadores mediante expresiones regulares:

• FS = "[,;]": separa por coma o punto y coma
• FS = "[ \t]+": separa por uno o más espacios o tabulaciones (igual que el valor predeterminado, pero de forma explícita)
• FS = "::": separa por dos puntos dobles literales
• FS = "\\|": separa por el carácter de barra vertical (se debe escapar)

Cuando FS es una expresión regular, awk (gawk) la trata como un patrón, no como una cadena literal.

OFS (separador de campos de salida) controla qué coloca awk entre los campos al reconstruir un registro con print. Su valor predeterminado es un espacio simple.

La idea clave es la siguiente: OFS solo se inserta entre campos cuando se usa la sintaxis con comas en print o cuando se asigna un valor a un campo y awk reconstruye $0. Si concatena con espacios en el código fuente, no se usa OFS.

• print $1, $2, $3: las comas activan OFS entre los campos
• print $1 " " $2: espacio explícito; se ignora OFS

Un patrón habitual es leer CSV, transformarlo y escribir TSV estableciendo FS="," y OFS="\t".

Existe un truco sutil pero importante: asignar un valor a cualquier campo (incluso asignarle el campo a sí mismo, $1=$1) obliga a awk a reconstruir $0 uniendo todos los campos con OFS.

Esta es la forma idiomática de reformatear los delimitadores de un registro sin imprimir manualmente cada campo:

• Establezca FS en el delimitador de entrada
• Establezca OFS en el delimitador de salida deseado
• Fuerce la reconstrucción con $1=$1
• Imprima $0

Este enfoque funciona con cualquier número de campos y evita escribir explícitamente $1, $2, $3, ....

Al igual que FS divide los campos dentro de un registro, RS (Record Separator) define qué separa unos registros de otros. De forma predeterminada, RS es un salto de línea, por lo que awk procesa una línea cada vez.

Cambiar RS permite procesar registros de varias líneas de forma muy potente:

• RS="" — modo párrafo: las líneas en blanco separan los registros (los campos pueden abarcar varias líneas)
• RS=";" — dividir por punto y coma (útil para volcados de SQL)
• RS="\n" — salto de línea explícito (el valor predeterminado)

En el modo párrafo (RS=""), FS sigue utilizándose para dividir los campos dentro del registro de varias líneas, y los saltos de línea dentro de un registro también se tratan automáticamente como separadores de campos.

ORS (Output Record Separator) se imprime después de cada sentencia print. De forma predeterminada es un salto de línea (\n), por eso cada print aparece en una línea nueva.

Cambiar ORS permite:

• Unir los registros en una sola línea: ORS=" "
• Añadir líneas en blanco entre los registros de salida: ORS="\n\n"
• Crear formatos de salida personalizados, como fragmentos de JSON o XML

Tenga en cuenta que printf no utiliza ORS: solo se aplica a la sentencia print sin formato adicional. Use printf cuando necesite controlar completamente el formato.

Los registros de acceso de Apache/nginx tienen un formato conocido, con campos separados por espacios. Algunos campos, como la marca de tiempo, contienen espacios y están delimitados por corchetes o comillas, lo que dificulta dividirlos directamente en campos con awk.

Un enfoque práctico consiste en usar un FS basado en una expresión regular que tenga en cuenta la estructura, o extraer campos concretos por posición cuando se conoce el formato exacto.

Los campos del formato de registro combinado son, a grandes rasgos:

1. Dirección IP del cliente
2. Ident (normalmente -)
3. Usuario autenticado (normalmente -)
4. Marca de tiempo (entre corchetes; cuenta como un solo token)
5. Método+ruta+protocolo de la solicitud (entre comillas)
6. Código de estado HTTP
7. Bytes de la respuesta

En la práctica de la ingeniería de shell, rara vez se utilizan estos separadores de forma aislada. Un patrón habitual de canalización consiste en usar awk como convertidor de formatos en una etapa intermedia, transformando un formato estructurado en otro.

Aspectos clave al combinar separadores:

• Establezca siempre FS y OFS juntos en BEGIN al convertir formatos
• Use $1=$1 para activar la reconstrucción de $0 cuando quiera reformatear todos los campos sin enumerarlos
• Cambie RS únicamente cuando los registros abarquen realmente varias líneas
• Use ORS para controlar el espaciado entre los registros de salida
• Prefiera printf para obtener un formato preciso; use print cuando resulte conveniente la terminación automática mediante ORS

Compruebe su comprensión de cómo interactúa OFS con la asignación de campos en awk.

Ahora tiene un control total sobre cómo awk lee y escribe datos estructurados. Este es un resumen de las cuatro variables de separación:

• FS — separador de campos de entrada. Se establece con -F o en BEGIN. Puede ser un carácter, una cadena o una expresión regular. Valor predeterminado: espacios en blanco.
• OFS — separador de campos de salida. Se inserta entre los campos en las llamadas print $1, $2 y cuando awk reconstruye $0 después de asignar un campo. Valor predeterminado: un solo espacio.
• RS — separador de registros de entrada. Define qué separa los registros (líneas). Valor predeterminado: salto de línea. Establézcalo como una cadena vacía para activar el modo párrafo.
• ORS — separador de registros de salida. Se añade después de cada print. Valor predeterminado: salto de línea. Cámbielo para unir líneas o añadir espacios.

El patrón más importante que debe recordar es el siguiente: establezca FS y OFS en BEGIN y, después, use $1=$1 para reconstruir $0 siempre que quiera reformatear los delimitadores de todos los campos sin codificar explícitamente sus posiciones. Este patrón funciona con archivos que tengan cualquier cantidad de columnas y constituye la base de las canalizaciones de conversión de formatos basadas en awk.