Procesamiento de texto en Linux: guía práctica con grep, sed y awk

El procesamiento de texto en Linux es una de esas habilidades que parecen pequeñas al principio, pero que terminan ahorrando muchísimo tiempo. Sirve para buscar información, leer logs, contar líneas, extraer columnas, limpiar archivos, transformar datos y automatizar tareas que serían lentas en una hoja de cálculo o en un editor gráfico.

La idea central es sencilla: Linux trata el texto como un flujo. Muchos comandos leen datos desde la entrada estándar, hacen una transformación concreta y escriben el resultado en la salida estándar. Gracias a las tuberías, puedes conectar herramientas pequeñas para resolver problemas reales con una sola línea de terminal.

En esta guía vas a ver los comandos más importantes para procesar texto en Linux, cuándo usar cada uno, ejemplos prácticos y errores frecuentes que conviene evitar.

👉 Y recuerda, si quieres aprender más de Linux, pincha en este curso de Linux gratis

👉 También te dejo por aquí una guía de comandos Linux por categorías

Qué es el procesamiento de texto en Linux

Procesamiento de texto en Linux significa tomar uno o varios archivos, o la salida de un comando, y aplicar una operación útil sobre ese contenido. Por ejemplo:

• Ver el contenido de un archivo.
• Buscar líneas que contienen una palabra o patrón.
• Contar líneas, palabras o caracteres.
• Extraer columnas de un archivo delimitado.
• Ordenar resultados.
• Eliminar duplicados.
• Reemplazar texto.
• Filtrar logs.
• Preparar datos para otro comando o script.

Linux funciona especialmente bien con texto plano: logs del sistema, archivos de configuración, listados, CSV sencillos, salidas de comandos y ficheros generados por scripts.

Un detalle importante: muchas herramientas de procesamiento de texto en Linux no modifican el archivo original. Normalmente leen datos y muestran el resultado por pantalla. Si quieres guardar esa salida, usas redirección.

Tabla resumen

Entrada, salida, tuberías y redirección

Antes de entrar en comandos concretos, conviene entender cuatro conceptos básicos.

La entrada estándar es de donde un comando lee datos. Puede ser el teclado, un archivo o la salida de otro comando.

La salida estándar es donde un comando escribe el resultado. Normalmente es la pantalla.

Una tubería, escrita con |, conecta la salida de un comando con la entrada de otro:

cat archivo.txt | grep "error"

cat archivo.txt | grep "error"

En este ejemplo, cat muestra el archivo y grep filtra las líneas que contienen la palabra error.

La redirección permite guardar resultados en archivos:

grep "error" sistema.log > errores.txt

grep "error" sistema.log > errores.txt

Esto guarda las líneas encontradas en errores.txt. Si el archivo ya existía, se sobrescribe.

Para añadir contenido al final sin borrar lo anterior, usa >>:

grep "warning" sistema.log >> errores.txt

grep "warning" sistema.log >> errores.txt

El error más común es confundir > con >>. El primer operador reemplaza el archivo completo; el segundo añade contenido al final.

Ver archivos con cat, less, head y tail

El primer paso en cualquier tarea de procesamiento de texto suele ser inspeccionar el contenido.

cat muestra un archivo completo:

cat notas.txt

cat notas.txt

Es útil para archivos pequeños, pero puede ser incómodo con ficheros largos porque todo pasa rápidamente por la pantalla.

Para leer archivos grandes, suele ser mejor less:

less sistema.log

less sistema.log

Dentro de less, puedes moverte con las flechas, buscar con /texto y salir con q.

Para ver solo el inicio de un archivo:

head archivo.txt

head archivo.txt

Por defecto muestra las primeras 10 líneas. Puedes elegir otra cantidad:

head -n 20 archivo.txt

head -n 20 archivo.txt

Para ver el final:

tail archivo.txt

tail archivo.txt

Y para seguir un archivo en tiempo real:

tail -f sistema.log

tail -f sistema.log

Esto es muy útil con logs. Por ejemplo, para ver los errores que se van generando:

tail -f sistema.log | grep "ERROR"

tail -f sistema.log | grep "ERROR"

Consejo práctico: no necesitas usar cat para todo. Muchos comandos pueden leer el archivo directamente:

grep "ERROR" sistema.log

grep "ERROR" sistema.log

Esto suele ser más claro que:

cat sistema.log | grep "ERROR"

cat sistema.log | grep "ERROR"

Contar líneas, palabras y caracteres con wc

wc significa word count, pero no solo cuenta palabras. También puede contar líneas, bytes y caracteres.

wc archivo.txt

wc archivo.txt

La salida muestra líneas, palabras y bytes.

Para contar solo líneas:

wc -l archivo.txt

wc -l archivo.txt

Para contar palabras:

wc -w archivo.txt

wc -w archivo.txt

Para contar caracteres:

wc -m archivo.txt

wc -m archivo.txt

Un uso habitual en procesamiento de texto es combinar grep con wc:

grep "error" sistema.log | wc -l

grep "error" sistema.log | wc -l

Primero se filtran las líneas que contienen error y después se cuentan.

Buscar texto con grep

grep es una de las herramientas más usadas para procesar texto en Linux. Sirve para buscar líneas que coinciden con una palabra, cadena o patrón.

grep "procesamiento" archivo.txt

grep "procesamiento" archivo.txt

Para ignorar mayúsculas y minúsculas:

grep -i "error" sistema.log

grep -i "error" sistema.log

Para mostrar el número de línea:

grep -n "error" sistema.log

grep -n "error" sistema.log

Para buscar de forma recursiva en una carpeta:

grep -R "TODO" proyecto/

grep -R "TODO" proyecto/

Para excluir líneas que contienen un patrón:

grep -v "debug" sistema.log

grep -v "debug" sistema.log

Ejemplo práctico: encontrar errores en el log del sistema, sin diferenciar entre error, Error o ERROR:

grep -i "error" /var/log/syslog

grep -i "error" /var/log/syslog

Si quieres profundizar en esta herramienta, puedes ampliar con la guía sobre el comando grep en Linux.

Error frecuente: olvidar las comillas cuando el patrón contiene espacios:

grep "error de conexión" archivo.txt

grep "error de conexión" archivo.txt

Sin comillas, la shell interpreta cada palabra como un argumento separado.

Extraer columnas con cut

cut sirve para extraer partes de cada línea. Es muy útil cuando el texto tiene columnas separadas por un delimitador claro, como dos puntos, comas o tabuladores.

Imagina un archivo usuarios.txt con este contenido:

ana:admin:34
luis:editor:28
marta:viewer:41

ana:admin:34
luis:editor:28
marta:viewer:41

Para extraer la primera columna:

cut -d ':' -f 1 usuarios.txt

cut -d ':' -f 1 usuarios.txt

Resultado:

ana
luis
marta

ana
luis
marta

Para extraer la segunda columna:

cut -d ':' -f 2 usuarios.txt

cut -d ':' -f 2 usuarios.txt

También puedes seleccionar varias columnas:

cut -d ':' -f 1,3 usuarios.txt

cut -d ':' -f 1,3 usuarios.txt

cut funciona muy bien cuando el delimitador es estable. Si las columnas están separadas por espacios variables o el archivo tiene una estructura más compleja, awk suele ser una opción más flexible.

Ordenar y eliminar duplicados con sort y uniq

sort ordena líneas:

sort nombres.txt

sort nombres.txt

Para ordenar numéricamente:

sort -n numeros.txt

sort -n numeros.txt

Para ordenar en sentido inverso:

sort -r nombres.txt

sort -r nombres.txt

uniq elimina líneas repetidas consecutivas:

uniq nombres.txt

uniq nombres.txt

Aquí hay un detalle importante: uniq solo detecta duplicados si están juntos. Por eso se combina casi siempre con sort:

sort nombres.txt | uniq

sort nombres.txt | uniq

Para contar cuántas veces aparece cada línea:

sort nombres.txt | uniq -c

sort nombres.txt | uniq -c

Y para ordenar ese conteo de mayor a menor:

sort nombres.txt | uniq -c | sort -nr

sort nombres.txt | uniq -c | sort -nr

Ejemplo práctico: ver las direcciones IP más repetidas en un log, suponiendo que la IP está en la primera columna:

cut -d ' ' -f 1 access.log | sort | uniq -c | sort -nr | head

cut -d ' ' -f 1 access.log | sort | uniq -c | sort -nr | head

Error común: usar uniq directamente sobre un archivo sin ordenarlo antes y esperar que elimine todos los duplicados del documento.

Transformar caracteres con tr

tr traduce, elimina o comprime caracteres. Lee desde la entrada estándar, así que normalmente se usa con tuberías o redirecciones.

Convertir minúsculas a mayúsculas:

echo "linux" | tr 'a-z' 'A-Z'

echo "linux" | tr 'a-z' 'A-Z'

Convertir espacios en saltos de línea:

echo "uno dos tres" | tr ' ' '\n'

echo "uno dos tres" | tr ' ' '\n'

Eliminar dígitos:

echo "abc123" | tr -d '0-9'

echo "abc123" | tr -d '0-9'

Comprimir espacios repetidos:

echo "uno     dos" | tr -s ' '

echo "uno     dos" | tr -s ' '

Ejemplo práctico: separar palabras, ordenarlas y contar repeticiones:

tr ' ' '\n' < texto.txt | sort | uniq -c | sort -nr

tr ' ' '\n' < texto.txt | sort | uniq -c | sort -nr

Error frecuente: intentar usar tr para reemplazar palabras completas. tr trabaja con caracteres, no con cadenas complejas. Para reemplazos de palabras, normalmente conviene usar sed.

Reemplazar texto con sed

sed es un editor orientado a flujos. Permite transformar líneas mientras pasan por el comando.

Reemplazar la primera aparición de una palabra en cada línea:

sed 's/viejo/nuevo/' archivo.txt

sed 's/viejo/nuevo/' archivo.txt

Reemplazar todas las apariciones:

sed 's/viejo/nuevo/g' archivo.txt

sed 's/viejo/nuevo/g' archivo.txt

Mostrar solo un rango de líneas:

sed -n '10,20p' archivo.txt

sed -n '10,20p' archivo.txt

Eliminar líneas vacías:

sed '/^$/d' archivo.txt

sed '/^$/d' archivo.txt

Ejemplo práctico: cambiar http:// por https:// en una lista de enlaces:

sed 's#http://#https://#g' enlaces.txt

sed 's#http://#https://#g' enlaces.txt

En este caso se usa # como separador en lugar de / para que las barras de las URLs no dificulten la lectura.

Por defecto, sed no cambia el archivo original. Muestra el resultado transformado. Para guardar en otro archivo:

sed 's/viejo/nuevo/g' archivo.txt > archivo_nuevo.txt

sed 's/viejo/nuevo/g' archivo.txt > archivo_nuevo.txt

Algunas versiones permiten editar el archivo directamente con -i:

sed -i 's/viejo/nuevo/g' archivo.txt

sed -i 's/viejo/nuevo/g' archivo.txt

Precaución: antes de usar sed -i en archivos importantes, prueba el comando sin -i o crea una copia. Un reemplazo masivo mal planteado puede dejar un archivo difícil de recuperar.

Procesar columnas y reglas con awk

awk es una herramienta muy potente para trabajar con datos estructurados por columnas. Lee línea por línea y permite imprimir campos, aplicar condiciones y hacer cálculos.

Por defecto, awk separa los campos por espacios o tabulaciones.

Imprimir la primera columna:

awk '{print $1}' archivo.txt

awk '{print $1}' archivo.txt

Imprimir la primera y tercera columna:

awk '{print $1, $3}' archivo.txt

awk '{print $1, $3}' archivo.txt

Filtrar líneas donde la tercera columna sea mayor que 100:

awk '$3 > 100 {print $0}' datos.txt

awk '$3 > 100 {print $0}' datos.txt

Sumar valores de una columna:

awk '{suma += $2} END {print suma}' datos.txt

awk '{suma += $2} END {print suma}' datos.txt

Cambiar el separador de campos:

awk -F ':' '{print $1}' /etc/passwd

awk -F ':' '{print $1}' /etc/passwd

Ejemplo práctico: mostrar usuario y shell en /etc/passwd:

awk -F ':' '{print $1, $7}' /etc/passwd

awk -F ':' '{print $1, $7}' /etc/passwd

awk suele ser mejor que cut cuando necesitas condiciones, cálculos, separadores más flexibles o procesamiento por columnas con reglas más completas.

Error frecuente: confundir $1 de awk con variables de la shell. Dentro de comillas simples, $1 pertenece a awk; fuera de ellas, la shell podría intentar expandirlo.

Ejemplos de procesamiento de texto en Linux

La verdadera potencia aparece al combinar comandos sencillos.

Contar errores en un log

grep -i "error" sistema.log | wc -l

grep -i "error" sistema.log | wc -l

Primero se buscan las líneas que contienen error; después se cuenta cuántas hay.

Ver los 10 términos más repetidos

tr ' ' '\n' < texto.txt | tr 'A-Z' 'a-z' | sort | uniq -c | sort -nr | head

tr ' ' '\n' < texto.txt | tr 'A-Z' 'a-z' | sort | uniq -c | sort -nr | head

Este pipeline separa palabras, convierte todo a minúsculas, ordena, cuenta duplicados, ordena por frecuencia y muestra los primeros resultados.

Extraer usuarios únicos de un archivo

cut -d ':' -f 1 usuarios.txt | sort | uniq

cut -d ':' -f 1 usuarios.txt | sort | uniq

Buscar archivos que contienen una palabra

grep -R -l "procesamiento" documentos/

grep -R -l "procesamiento" documentos/

La opción -l muestra solo los nombres de archivo donde hubo coincidencias.

Ver las líneas recientes que coinciden con un patrón

tail -n 200 sistema.log | grep "ERROR"

tail -n 200 sistema.log | grep "ERROR"

Esto limita el análisis a las últimas 200 líneas del log.

Obtener las IP más frecuentes de un log web

awk '{print $1}' access.log | sort | uniq -c | sort -nr | head

awk '{print $1}' access.log | sort | uniq -c | sort -nr | head

Es una forma rápida de detectar clientes muy repetidos, posibles bots o direcciones que generan mucho tráfico.

Redirección de errores

Además de la salida estándar, existe la salida de error estándar. Muchos comandos escriben errores por separado.

Guardar errores en un archivo:

comando 2> errores.txt

comando 2> errores.txt

Guardar salida normal y errores juntos:

comando > salida.txt 2>&1

comando > salida.txt 2>&1

Descartar errores:

comando 2>/dev/null

comando 2>/dev/null

Ejemplo práctico:

grep -R "texto" /etc 2>/dev/null

grep -R "texto" /etc 2>/dev/null

Así se evitan mensajes de permisos denegados mientras se buscan coincidencias.

Error común: no distinguir entre salida normal y salida de error. Si rediriges solo con >, los errores pueden seguir apareciendo en pantalla.

Conclusión

El procesamiento de texto en Linux se basa en combinar herramientas pequeñas que hacen una tarea concreta. Con comandos como grep, cut, sort, uniq, tr, sed y awk, puedes analizar logs, limpiar datos, extraer información y automatizar tareas repetitivas.

Para empezar, practica con archivos simples y construye pipelines poco a poco. Cuando una combinación funcione, puedes guardarla en un script y reutilizarla. Esa es una de las razones por las que Linux sigue siendo tan útil para administradores, desarrolladores y cualquier persona que trabaje con datos en texto plano.