El comando awk en Linux: cómo entender la sintaxis, las opciones y los ejemplos más comunes

El comando awk de Linux se utiliza ampliamente para tareas de procesamiento de texto. Puedes usar este comando directamente en la terminal para extraer datos de un archivo de texto, buscar patrones y realizar acciones sencillas, como dar formato al texto.

Este comando también es un lenguaje de programación, lo que significa que puedes usarlo para escribir programas completos. Sin embargo, este artículo se centrará en lo que puedes hacer con el comando awk en la terminal para manipular archivos de texto. Cubriremos la sintaxis, los casos de uso más comunes y responderemos las preguntas más frecuentes.

Sintaxis del comando awk

En esencia, el comando awk recibe dos tipos de entrada: un archivo de texto y un conjunto de instrucciones. Esto se refleja en la sintaxis básica:

awk '{ acción }' filename.txt

• La acción corresponde a lo que quieres hacer en tu archivo de texto.
• filename es el archivo de texto.

En su nivel más básico, la sintaxis del comando awk es muy simple. Todo lo que necesitas es un archivo de texto con el que puedas interactuar y una acción para realizar.

Opciones y variaciones de sintaxis

Tu comando básico de awk puede ampliarse aún más si añades opciones:

• -F: define un separador de campos.
• -v: define variables.
• -f: lee el script desde un archivo.

Como awk usa los espacios en blanco, ya sean espacios o tabulaciones, como delimitador predeterminado entre los campos de un archivo o de la entrada, -F le indica cómo interpretar las columnas o los campos de cada línea según un delimitador. En otras palabras, cuando usas -F, awk sabe cómo dividir cada línea en partes (campos).

Con el documento que usaste antes, puedes usar -F como argumento de línea de comandos para definir los dos puntos como separador de campos.

awk -F':' '/casa/ { print "ID:", $1, "- Tipo:", $2, "- Ubicación:", $3 }' filename.txt

awk identifica el separador e interpreta los campos según corresponda:

ID: 1. Tipo: Casa grande. Ubicación: Nueva York.

ID: 2. Tipo: Casa pequeña. Ubicación: Los Ángeles.

ID: 4. Tipo: Casa flotante. Ubicación: Seattle

Para asignar una variable desde la línea de comandos, puedes ejecutar:

awk -v word="casa" '$0 ~ word { print $0 }' filename.txt

Ahora, word es una variable que puedes usar en tu acción.

Por último, la opción -f te sirve para ejecutar varios comandos de awk a la vez desde la línea de comandos dentro de un solo script. Imagina que tienes un archivo simple_script.awk que contiene lo siguiente:

# Muestra el número de línea y el contenido de la línea si la línea contiene la palabra "casa"

$0 ~ /casa/ { print NR, $0 }

# Muestra un mensaje antes de cada salida

BEGIN { print "Empezando a buscar 'casa'..." }

Puedes ejecutar esto con:

awk -f simple_script.awk filename.txt

Y tendrás:

Empezando a buscar 'casa'...
1: Casa grande: Nueva York
2: Casa pequeña: Los Ángeles
4: Casa flotante: Seattle

Crear un archivo de muestra

Antes de hablar sobre casos de uso, tendrás que crear un archivo de ejemplo.

Para este ejemplo, seguiremos usando casas y ubicaciones como ejemplos, pero crea un archivo de entrada completamente nuevo.

Para hacerlo, solo usa el comando touch para crear un archivo nuevo:

touch casas.txt

Como el archivo está vacío, necesitamos llenarlo. Cambiemos también las viviendas de nuestro primer ejemplo: podríamos querer una casa pequeña en Vermont, una casa grande en San Diego, un apartamento en Nueva York y una casa flotante en Londres. También añadiremos los metros cuadrados de cada hogar.

Puedes usar tu editor de texto preferido, como nano o vim, o añadir datos directamente con echo.

echo -e "1:Casa pequeña:Vermont:100 m²n2:Casa grande:San Diego:300 m²n3:Apartamento:Nueva York:70 m²n4:Casa flotante:Londres:40 m²" > casas.txt

Ahora, casas.txt está listo para que lo uses en nuestros ejemplos de awk.

Ejemplos del comando awk

Veamos cómo podemos usar el comando awk en nuestro archivo casas.txt en varios casos de uso. A continuación, encontrarás una lista de situaciones comunes.

1. Mostrar todas las líneas de un archivo

Para mostrar todas las líneas de un archivo de entrada, ejecuta el siguiente comando:

awk '{print}' casas.txt

Esto devolverá lo siguiente:

1:Casa pequeña:Vermont:100 m²

2:Casa grande:San Diego:300 m²

3:Apartamento:Nueva York:70 m²

4:Casa flotante:Londres:40 m²

2. Mostrar una columna específica

Como ya vimos, awk divide cada línea de un archivo de texto en campos o columnas usando espacios en blanco como separador. En nuestro caso, estamos usando dos puntos (:). Para mostrar columnas específicas, necesitamos saber la posición de la columna dentro de la línea.

Imaginemos que quieres mostrar la columna que contiene los metros cuadrados de cada casa. Para hacer esto, ejecutaremos:

awk -F':' '{print $4}' casas.txt

El resultado será:

100 m²

300 m²

70 m²

40 m²

Aquí:

• -F’:’ le dice a awk que use dos puntos (:) como separador de campos.
• $4 muestra el cuarto campo (los metros cuadrados).

3. Mostrar las líneas que coinciden con un patrón

Imagina que solo te interesan las líneas de tu archivo de entrada que contienen una determinada palabra o que coinciden con un cierto patrón. Para hacer esto, tendrás que usar expresiones regulares.

Las expresiones regulares son una técnica de coincidencia de patrones y pueden usarse para crear patrones complejos que extraigan partes muy específicas de un texto. Aquí usaremos una expresión regular muy sencilla.

Por ejemplo, si quieres mostrar toda la línea que contiene la palabra “Casa flotante” de tu archivo de entrada, ejecutarás:

awk -F ':' '/Casa flotante/ {print}' casas.txt

Lo que te dará:

4:Casa flotante:Londres:40 m²

/Casa flotante/ es el patrón de expresión regular: le estamos indicando al sistema que busque todo el texto que coincida con la palabra “Casa flotante”.

4. Extraer e mostrar columnas mediante la manipulación de campos

También puedes modificar los campos dentro de tu archivo de texto y mostrarlos en un orden diferente.

Supongamos que quieres mostrar cada línea de nuestro archivo de texto como un anuncio inmobiliario. Puedes hacer lo siguiente:

awk -F ':' '{print "En venta:", $2, "en", $3, ".", "Superficie:", $4}' casas.txt

Al ejecutar este comando, se mostrará:

awk -F ':' '{print "En venta:", $2, "en", $3, ".", "Superficie:", $4}' casas.txt

En venta: Casa pequeña en Vermont . Superficie: 100 m²
En venta: Casa grande en San Diego . Superficie: 300 m²
En venta: Apartamento en Nueva York . Superficie: 70 m²
En venta: Casa flotante en Londres . Superficie: 40 m²

El comando te permite reorganizar y dar formato a los campos como quieras. Por ejemplo, podrías intercambiar $2 y $3 para mostrar la ubicación antes del tipo de casa.

5. Calcular operaciones matemáticas

El comando awk puede realizar cálculos.

Añadamos una columna a nuestros datos que contenga el precio de cada propiedad.

awk -F ':' '{print $0, ": $", NR * 100000}' casas.txt > precio_casas.txt

Este comando crea un archivo precio_casas.txt con los precios de todas las propiedades. Para simplificar, inventaremos precios según el número de línea con: $, NR * 100000.

1: Casa pequeña:Vermont: 100 m²: $100000

2:Casa grande:San Diego:300 m²: $200000

3:Apartamento:Nueva York:70 m²: $300000

4:Casa flotante:Londres:40 m²:$400000

Ahora que tenemos algunos números, podemos probar operaciones matemáticas.

Para calcular el coste total de las propiedades, sumarás la última columna, donde se guardan los precios ($5):

awk -F ':' '{gsub("[$,]", "", $5); sum += $5} END {print "Coste total:", sum}' precio_casas.txt

Lo que se muestra:

Coste total: 1000000

Aquí:

• gsub(“[$,]”, “”, $5) elimina cualquier signo de dólar o coma del precio en el quinto campo para permitir un cálculo correcto.
• sum += $5 suma el precio al total acumulado.
• END {print “Coste total:”, sum} muestra el coste total después de procesar todas las líneas.

6. Procesamiento de datos según instrucciones condicionales

Para calcular solo el precio de las propiedades seleccionadas, por ejemplo, el apartamento en Nueva York y la casa flotante en Londres, tendrás que usar instrucciones condicionales.

awk -F ':' '($2 == "Apartamento" || $2 == "Casa flotante") {gsub("[$,]", "", $5); sum += $5} END {print "NY + LDN, costo total:", sum}' precio_casas.txt

En este ejemplo:

• $2 == “Apartmento” || $2 == “Casa flotante” es la condición que garantiza que solo se procesen las líneas que contienen “Apartmento” o “Casa flotante”. || es el símbolo condicional de «o».
• gsub(“[$,]”, “”, $5) elimina los signos de dólar o las comas.
• sum += $5 añade el precio a la suma.
• END {print “NY + LDR, coste total:”, sum} muestra el coste total de las propiedades seleccionadas.

El comando anterior mostrará:

NY + LDR, coste total: 700000

Usando nuestro archivo de entrada original casas.txt, puedes usar otra instrucción condicional para, por ejemplo, mostrar una propiedad solo si tiene más de 50 m²:

awk -F ':' '{if ($4 > 50) print $2, "en", $3, ":", "OK"; else print $2, "en", $3, ":", "demasiado pequeña."}' casas.txt

El comando anterior usa una instrucción condicional simple if-else separada por un punto y coma (;). Se mostrará:

awk -F ':' '{if ($4 > 50) print $2, "en", $3, ":", "OK"; else print $2, "en", $3, ":", "demasiado pequeña."}' casas.txt

Casa pequeña en Vermont : demasiado pequeña
Casa grande en San Diego : demasiado pequeña
Apartamento en Nueva York : OK
Casa flotante en Londres : demasiado pequeña

Puedes encontrar todas las instrucciones condicionales en el manual del usuario de GNU Awk.

7. Uso de variables integradas

El comando awk tiene varias variables integradas, tanto numéricas como de texto, que están predefinidas en el lenguaje.

Aquí tienes las más usadas:

• NR (número de registros)
• NF (número de campos)
• FS (separador de campos)
• OFS (separador de campos de salida)
• FILENAME (nombre de archivo)
• RS (separador de registros)

Por ejemplo, para mostrar el número de campos en cada línea, ejecutarías:

awk -F ':' '{print "La línea", NR, "tiene", NF, "campos"}' casas.txt

Lo que produciría:

La línea 1 tiene 4 campos
La línea 2 tiene 4 campos
La línea 3 tiene 4 campos
La línea 4 tiene 4 campos

Si quieres usar OFS para especificar el separador entre campos al mostrar la salida, puedes ejecutar:

awk 'BEGIN {OFS="XXXX"} {print $1, $2, $3, $4}' casas.txt

Lo que se mostrará:

1:CasaXXXXpequeña:Vermont:100XXXXm²
2:CasaXXXXgrande:SanXXXXDiego:300XXXXm²
3:Apartamento:NuevaXXXXYork:70XXXXm²XXXX
4:CasaXXXXflotante:Londres:40XXXXXXXXm²XXXXXXXX

8. Uso de funciones definidas por el usuario

Con el comando awk, puedes manipular tu texto de forma más eficiente al usar funciones directamente en la terminal.

Por ejemplo, para convertir la segunda columna (tipos de casas) a minúsculas, ejecutarás:

awk -F ':' '{print tolower($2)}' casas.txt

Lo que produce:

casa pequeña

casa grande

apartamento

casa flotante

Aquí, tolower($2) es la función que se está usando.

Si quieres reemplazar la palabra “casa” por “mansión” en la segunda columna:

awk -F ':' '{gsub(/casa/, "mansión", $2); print $2}' casas.txt

Donde gsub(/casa/, “mansión”, $2) es la función.

Pequeña mansión

Gran mansión

Apartamento

Casa flotante

Conclusión

El comando awk de Linux es una herramienta de procesamiento potente que los desarrolladores pueden usar para extraer, manipular y procesar datos de archivos de texto. Puede ser especialmente útil para tareas como analizar registros o incluso archivos CSV, ya que admite operaciones matemáticas, coincidencia de patrones y manipulación de campos.

Al dominar los conceptos básicos del comando awk, pronto podrás usarlo de manera eficiente en distintas tareas, mantener tus documentos organizados y tener funciones potentes al alcance de tu mano.

Preguntas frecuentes sobre el comando awk

Todo el contenido tutorial en este sitio web está sujeto a los estándares y valores editoriales más rigurosos de Hostinger.

El autor

Rafael L.

Rafael es un experto en marketing digital y localización de software con más de 10 años de experiencia. Le apasiona la comunicación y la tecnología. Si no está traduciendo o escribiendo, está inmerso en un videojuego o cuidando del jardín.

Más de Rafael L.