Mis apuntes · Aprende awk desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 26 de 31 · Varios ficheros y salida ✦ WebMCP implementado

RS: registros de varias líneas y CSV

9 min de lectura 4 retos

awk lee «línea a línea»… porque nadie le ha dicho otra cosa. En esta lección cambias dónde corta: con RS un error de PHP que ocupa cuatro líneas pasa a ser una sola pieza, y cada línea suya un campo. Al final ves qué hacer con el CSV de verdad, el que lleva comas dentro de comillas.

¿De dónde vienen los nombres?

registro = inglés record (ficha, apunte)
Cada trozo que awk lee de una vez y le pasa a tus reglas. Hasta hoy un registro era una línea; por eso NR es Number of Records y no «number of lines».
RS = Record Separator (separador de registros)
Lo que marca dónde acaba un registro y empieza el siguiente. De fábrica es el salto de línea. Es el hermano mayor de FS, que separa los campos.
ORS = Output Record Separator (separador de registros de salida)
Lo que print escribe al final de cada cosa que imprime. De fábrica, un salto de línea: el PHP_EOL que tú pones a mano.
RT = Record Terminator (terminador del registro)
Solo gawk. El texto exacto que cerró el registro que acabas de leer. Útil cuando RS es una regex y puede encajar con cosas distintas.
FPAT = Field PATtern (patrón de campo)
Solo gawk. En vez de decir qué separa los campos, dices qué pinta tiene un campo.
CSV = Comma-Separated Values (valores separados por comas)
El formato de exportar de las hojas de cálculo. Es lo que lee fgetcsv() en PHP.
En 4 ideas
1/4

awk no lee líneas: lee registros, y RS dice dónde acaba cada uno. De fábrica es "\n". Es elegir el separador del explode() con el que partes el fichero entero.

1 · Un error que ocupa varias líneas

Junto al log de accesos, tu servidor tiene otro: error.log, donde PHP apunta sus errores. Abre su pestaña en la caja de abajo y fíjate en la forma: cada error ocupa varias líneas (la fecha, el mensaje, el fichero y a veces la traza) y entre un error y el siguiente hay una línea en blanco.

Con lo que sabes hasta hoy, awk lo trata línea a línea. Pregúntale cuántas cosas ha leído:

awkprograma.awk
# En PHP: echo "Registros: ", count(file("error.log")), PHP_EOL;
END { print "Registros: " NR }
$ awk -f programa.awk error.log
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. error.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

Dice 22, pero en el fichero hay 5 errores. awk ha contado líneas sueltas, incluidas las que están en blanco. Así no puedes preguntar «¿en qué fichero falló el error de las 10:22?», porque la hora está en una línea y el fichero en otra, y awk ya no recuerda la anterior.

Es como leer una carta palabra a palabra, con un papel que tapa todo lo demás. Lo que necesitas es mover el papel de párrafo en párrafo.

2 · RS vacío: el modo párrafo

RS se cambia en el BEGIN, igual que FS: antes de leer nada. El valor que más se usa es el texto vacío. Significa «un registro es un bloque de líneas hasta la siguiente línea en blanco»:

awkprograma.awk
# En PHP: $registros = preg_split('/\n{2,}/', trim(file_get_contents("error.log")));
BEGIN { RS = "" }
END { print "Registros: " NR }
$ awk -f programa.awk error.log
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. error.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

Ahora sí: 5. Cada error entero es un registro, y $0 contiene todas sus líneas. Falta partirlo en campos. Si le dices que el separador de campos es el salto de línea, cada línea del error es un campo:

PHP 8.5errores.php
<?php
$texto = trim(file_get_contents("error.log"));
// un registro por cada bloque separado por líneas en blanco
$registros = preg_split('/\n{2,}/', $texto);
foreach ($registros as $numero => $registro) {
    // cada línea del bloque es un campo
    $campos = explode("\n", $registro);
    // la segunda línea es el mensaje de PHP
    echo $numero + 1, ": ", $campos[1], PHP_EOL;
}
awkprograma.awk
# En PHP: preg_split('/\n{2,}/', $texto) y explode("\n", $registro)
BEGIN { RS = ""; FS = "\n" }
# En PHP: echo $numero + 1, ": ", $campos[1], PHP_EOL;
{ print NR ": " $2 }
$ awk -f programa.awk error.log
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. error.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

Medido en el servidor del curso con error.log multiplicado hasta 999.988 líneas: PHP 8.5: 361 ms · gawk: 669 ms · mawk: 120 ms. awk tarda 3,0 veces menos que PHP.

En error.log, con RS = "" y FS = "\n"Qué contiene
$0El error entero, con sus saltos de línea
$1La primera línea: fecha, nivel (ERROR, WARNING, NOTICE) y proceso
$2El mensaje de PHP
$3El fichero y la línea donde falló
$4, $5…La traza, si la hay
NFCuántas líneas tiene este error
NRQué número de error es

Y con eso, todo lo que ya sabes funciona sobre errores enteros. Por ejemplo, quedarte con los graves y ver cuántas líneas ocupa cada uno:

awkprograma.awk
BEGIN { RS = ""; FS = "\n" }
# En PHP: if (str_contains($campos[0], "ERROR")) { echo count($campos), " líneas: ", $campos[1], PHP_EOL; }
$1 ~ /ERROR/ { print NF " líneas: " $2 }
$ awk -f programa.awk error.log
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. error.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

¿Por qué? · En PHP no existe

¿Por qué RS vacío significa «párrafos» y no «sin separador»?

Es un caso especial que los autores de awk metieron a propósito. Los ficheros con fichas separadas por una línea en blanco eran (y son) muy corrientes: logs de errores, agendas, ficheros de configuración. Querían una forma corta de leerlos.

Lo lógico sería RS = "\n\n", «dos saltos seguidos». Pero el awk clásico solo miraba el primer carácter de RS, así que eso no se podía escribir. Eligieron el texto vacío como contraseña.

El modo párrafo hace además dos favores que un explode("\n\n", $texto) de PHP no hace: junta varias líneas en blanco seguidas como si fueran una, y no crea un registro vacío por las que haya al principio o al final del fichero. Por eso el PHP de arriba necesita preg_split con {2,} y un trim().

3 · ORS y OFS: cómo sale lo que imprimes

RS decide cómo entran los registros. Su pareja, ORS, decide qué pone print al final de cada cosa que imprime. De fábrica es un salto de línea, y por eso nunca has escrito un PHP_EOL.

Si filtras errores enteros y los imprimes tal cual, salen pegados uno debajo de otro y ya no se ve dónde acaba cada uno. Poniendo ORS a dos saltos de línea, la salida vuelve a tener su línea en blanco y se puede leer otra vez en modo párrafo:

awkprograma.awk
# En PHP: echo $registro, "\n\n";
BEGIN { RS = ""; ORS = "\n\n" }
# sin accion: imprime el registro entero, y print termina con ORS
/ERROR:/
$ awk -f programa.awk error.log
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. error.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

El otro truco útil es el contrario: dejar cada error en una sola línea, para poder buscar en él con herramientas que van línea a línea. Ya conoces las piezas del módulo 02: OFS es lo que se pone entre campo y campo al imprimir, y $1 = $1 obliga a awk a montar $0 otra vez con ese separador.

awkprograma.awk
# En PHP: echo implode(" | ", explode("\n", $registro)), PHP_EOL;
BEGIN { RS = ""; FS = "\n"; OFS = " | " }
{ $1 = $1; print }
$ awk -f programa.awk error.log
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. error.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

VariableQué separaCuándo actúaDe fábricaEn PHP
RSRegistrosAl leerSalto de líneaEl separador con el que partes el fichero
FSCamposAl leerEspacios y tabuladoresEl de explode() sobre cada registro
OFSCamposAl imprimir con comaUn espacioEl de implode()
ORSRegistrosAl imprimirSalto de líneaPHP_EOL

4 · RS de un carácter, RS como regex y RT

RS puede ser cualquier carácter, no solo el salto de línea. Aquí se lee usuarios.csv cortando por el punto y coma, así que cada celda es un registro. Mira bien el quinto:

awkprograma.awk
# En PHP: $registros = explode(";", file_get_contents("usuarios.csv"));
BEGIN { RS = ";" }
NR <= 6 { print NR ": " $0 }
$ awk -f programa.awk usuarios.csv
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. usuarios.csv: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

El registro 5 ocupa dos líneas: ultimo_acceso, un salto y el 1 de la fila siguiente. Tiene sentido: le has dicho que solo corte en los ;, así que el salto de línea ha dejado de ser especial y viaja dentro del registro como una letra más.

Sirve para ficheros que vienen en una sola línea larguísima con las fichas separadas por un carácter. En PHP harías explode() sobre el fichero entero; awk hace lo mismo pero sin cargarlo todo en memoria.

Solo gawk: si RS tiene más de un carácter, gawk lo trata como una regex. Y como una regex puede encajar con textos distintos, gawk te deja en la variable RT el texto exacto que cerró cada registro. Aquí se corta error.log por la palabra del nivel:

awkprograma.awk
# En PHP: preg_split('/(WARNING|ERROR|NOTICE): /', $texto, -1, PREG_SPLIT_DELIM_CAPTURE)
BEGIN { RS = "(WARNING|ERROR|NOTICE): " }
RT != "" { print "El trozo " NR " acaba en: " RT }
$ awk -f programa.awk error.log
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. error.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

En PHP, explode() y preg_split() tiran el separador (salvo que pidas PREG_SPLIT_DELIM_CAPTURE). RT es la forma que tiene gawk de devolvértelo.

5 · El CSV de verdad: FPAT y --csv

En el módulo 02 leíste usuarios.csv con -F ';' y funcionó, porque ninguna celda llevaba un ; dentro. El CSV de verdad tiene una trampa: una celda puede contener el separador si va entre comillas. Este fichero tiene tres columnas (IP, estado y navegador), y el navegador de la segunda visita lleva una coma dentro:

$ cat visitas.csv
ip,estado,navegador
203.0.113.7,200,"Mozilla/5.0 (X11; Linux x86_64) Gecko/20100101 Firefox/131.0"
192.0.2.55,500,"Mozilla/5.0 (KHTML, like Gecko) Chrome/130.0.0.0"
66.249.66.1,200,"Mozilla/5.0 (compatible; Googlebot/2.1)"

$ awk -F, 'NR > 1 { print NF " campos, el tercero: " $3 }' visitas.csv
3 campos, el tercero: "Mozilla/5.0 (X11; Linux x86_64) Gecko/20100101 Firefox/131.0"
4 campos, el tercero: "Mozilla/5.0 (KHTML
3 campos, el tercero: "Mozilla/5.0 (compatible; Googlebot/2.1)"

La segunda fila sale con 4 campos y el navegador partido por la mitad. FS no sabe nada de comillas: corta en todas las comas. Es el mismo fallo que tendrías en PHP con explode(",", $linea), y la razón por la que existe fgetcsv().

Solo gawk (desde la versión 5.3) tiene la opción --csv, que entiende las comillas como las entiende fgetcsv() y además te las quita:

awkprograma.awkSolo lectura: necesita gawk 5.3 o posterior con --csv
# En PHP: while (($campos = fgetcsv($fichero)) !== false) { echo count($campos), " campos, el tercero: ", $campos[2], PHP_EOL; }
NR > 1 { print NF " campos, el tercero: " $3 }
$ gawk --csv -f programa.awk visitas.csv
3 campos, el tercero: Mozilla/5.0 (X11; Linux x86_64) Gecko/20100101 Firefox/131.0
3 campos, el tercero: Mozilla/5.0 (KHTML, like Gecko) Chrome/130.0.0.0
3 campos, el tercero: Mozilla/5.0 (compatible; Googlebot/2.1)

La otra herramienta de gawk es más general y sí la puedes ejecutar aquí: FPAT. Le da la vuelta a la idea de FS. No dices qué separa los campos; dices qué pinta tiene un campo, con una regex. Y resulta que resuelve un problema que arrastras desde el módulo 01: el navegador del log, que con espacios se rompía en muchos campos.

awkprograma.awk
# En PHP: preg_match_all('/"[^"]*"|\[[^]]*\]|[^ ]+/', $linea, $campos);
BEGIN { FPAT = "([^ ]+)|(\"[^\"]*\")|(\\[[^]]*\\])" }
NR <= 3 { print NF " campos. Estado: " $6 ". Navegador: " $9 }
$ awk -f programa.awk access.log
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. access.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

La regex tiene tres formas posibles de campo, separadas por |, y gawk se queda con la que más texto coge:

  1. [^ ]+: un trozo sin espacios. Es el campo de toda la vida (la IP, el estado, los bytes).
  2. \"[^\"]*\": unas comillas, lo que haya dentro y las comillas de cierre. La petición, el referer y el navegador, enteros.
  3. \\[[^]]*\\]: un corchete, lo que haya dentro y su cierre. La fecha con su zona horaria.

La línea del log pasa de tener entre 12 y 28 campos, según el navegador, a tener siempre 9. Ojo: los números cambian respecto al resto del curso (el estado pasa a ser $6) y las comillas siguen ahí, no se quitan.

¿Por qué? · En PHP no existe

¿Por qué FPAT describe el campo en vez del separador?

Porque hay formatos en los que el separador no se puede describir. En un CSV, una coma separa… salvo que esté entre comillas. En el log, un espacio separa… salvo que esté entre comillas o entre corchetes. Con FS solo puedes decir «corta aquí», no «corta aquí salvo que».

Describir el campo es darle la vuelta: «un campo es esto, o esto otro». Es la misma diferencia que hay en PHP entre preg_split() (dices por dónde cortar) y preg_match_all() (dices qué quieres encontrar).

El fallo que evita es el más silencioso de todos: un explode(",", $linea) sobre un CSV funciona durante meses, hasta el día en que un cliente se llama «García, S.L.» y todas las columnas de esa fila se corren un sitio.

La pregunta que te vas a hacer

¿Y en mawk o en un gawk antiguo? ¿Cuándo dejo awk y vuelvo a PHP?

Mira primero qué tienes: awk --version. Si no es gawk, no hay FPAT ni --csv; si es un gawk anterior al 5.3, hay FPAT pero no --csv. Y como siempre, no dan error: FPAT sería una variable más y el fichero se partiría por espacios.

  • Para el log, lo que funciona en cualquier awk es lo del módulo 02: -F '"' y coger el navegador en $6.
  • Para un CSV sin comillas, -F ',' o -F ';' de toda la vida.
  • Para un CSV con comillas y sin gawk 5.3: vuelve a PHP. fgetcsv() lo hace bien, incluidas las celdas con saltos de línea dentro.

No es una derrota. awk es el pelapatatas del cajón: perfecto para ficheros de líneas y columnas sencillas. Cuando el formato tiene reglas con excepciones, coge la herramienta que ya las conoce.

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

¿Cuántos errores hay?

El programa dice cuántos registros ha leído de error.log, pero cuenta líneas sueltas. Haz que cuente errores enteros (bloques separados por una línea en blanco). Debe imprimir Registros: 5. En PHP: count(preg_split('/\n{2,}/', trim($texto))).

Al pulsar Comprobar, tu programa se ejecuta en tu navegador con el fichero que ves y con otro distinto que no ves: tiene que acertar con los dos.

awkprograma.awk · editable
$ awk -f programa.awk error.log
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. error.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

Resumen

Lo que te llevas de esta lección

  1. awk lee registros; RS dice dónde se cortan. De fábrica, en cada salto de línea. NR cuenta registros, no líneas.
  2. BEGIN { RS = "" } es el modo párrafo: un registro por bloque separado por líneas en blanco. En PHP, preg_split('/\n{2,}/', trim($texto)).
  3. Con FS = "\n" cada línea del bloque es un campo y NF son sus líneas: explode("\n", $bloque) y count().
  4. ORS es lo que print añade al final, tu PHP_EOL. Con ORS = "\n\n" la salida vuelve a ir en párrafos; con OFS y $1 = $1 aplastas un registro en una línea.
  5. RS de un carácter funciona en cualquier awk. RS como regex y RT son Solo gawk.
  6. CSV con comillas: --csv (Solo gawk 5.3+) o FPAT (Solo gawk), que describe el campo en vez del separador. Sin gawk, fgetcsv() de PHP.

Para recordarlo: «RS corta el fichero; FS corta el registro»

RRS
fichero → registros
FFS
registro → campos
OOFS · ORS
lo mismo, al imprimir

Primero se parte el fichero en registros y después cada registro en campos: dos explode() uno dentro de otro. Y las dos que llevan una O delante hacen el camino de vuelta, al imprimir.

Los programas se ejecutan con GNU awk 5.4.1 compilado a WebAssembly, software libre con licencia GPL-3.0. Código fuente: gawk en ftp.gnu.org · receta de compilación.