Sed Cambia Mayúsculas: Minúsculas, Mayúsculas y Title Case con Ejemplos

¿Necesitas cambiar mayúsculas con sed? Esta guía cubre cada técnica de sed para cambiar mayúsculas: sed a minúsculas, sed a mayúsculas y sed a title case, construidas con el comando portable y, los modificadores \L/\U de GNU sed, y \u para caracteres sueltos. Todos los ejemplos están verificados contra GNU sed 4.9, con notas para GNU sed 4.10 y macOS/BSD donde el comportamiento difiere. Útil para limpiar datos, normalizar niveles de log y arreglar extensiones de archivo en batch.

El artículo va desde los comandos básicos hasta la edición in-place, el procesamiento por lotes y las trampas que hacen que sed a minúsculas “no funcione” (casi siempre es el shorthand de rango de y o el locale). Hay una chuleta al final si solo necesitas los comandos.

¿Qué es Sed?

sed (Stream Editor) es una herramienta de línea de comandos para manipulación de texto. Procesa la entrada línea a línea, lo que lo hace rápido para archivos grandes. Si aún estás construyendo tu toolkit, va junto a grep, awk y curl en la chuleta de comandos esenciales de Linux.

Sed es genial para conversión de mayúsculas porque:

• Funciona no interactivamente (sin prompts)
• Maneja archivos grandes eficientemente (memoria constante, una línea cada vez)
• Puede apuntar a patrones o rangos de líneas específicos
• Funciona con pipes y otros comandos

Otras guías de sed de esta serie:

• sed buscar y reemplazar
• borrar líneas con sed
• insertar o añadir texto con sed

Cuándo Cambiar Mayúsculas con Sed

Situaciones comunes:

• Limpieza de datos - estandariza nombres o campos. Jon, JON y jon en la misma columna es un bug de calidad de datos esperando morder un join.
• Formato de logs - haz los niveles de error consistentes. ERROR, Error y error en un archivo de log rompen greps ingenuos y dashboards de logs.
• Archivos de config - algunas apps exigen claves en minúsculas, otras gritan todo en caps. Cambiar mayúsculas a mano en un archivo de 200 líneas es cómo ocurren los typos.
• Procesamiento por lotes - extensiones de archivo, headers HTTP, encabezados de columnas CSV, nombres de servicios docker-compose.

Sed es la herramienta correcta cuando la conversión es por líneas o apuntada por patrón. Si solo necesitas voltear un stream entero de mayúsculas a minúsculas sin condiciones, tr es más rápido (números en la sección tr vs sed vs awk). La conversión de mayúsculas es barata en CPU en archivos pequeños y medianos de todas formas.

Sed a Minúsculas y Mayúsculas: Los Comandos Básicos

Hay dos familias de conversión de mayúsculas en sed, más modificadores por carácter:

1. El comando y - portable, funciona en sed de GNU, BSD y macOS. Basado en listas de caracteres.
2. Los modificadores de reemplazo \L y \U - solo GNU sed. Más cortos, y se componen con otras sustituciones.
3. \u, \l, \E - solo GNU sed. Controlan mayúsculas por carácter, que es cómo se construye el title case.

La mayoría de flujos de cambio de mayúsculas en sed empiezan con uno de los dos primeros.

Convertir Mayúsculas con el Comando y (Portable)

y translitera un conjunto de caracteres a otro. Debes listar cada carácter. Esto funciona donde funciona sed.

Convertir a minúsculas:

echo "HELLO WORLD" | sed 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/'
# Output: hello world

Convertir a mayúsculas:

echo "hello world" | sed 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'
# Output: HELLO WORLD

echo "ABC az AZ 09" | sed 'y/A-Z/a-z/'
# Output: aBC az az 09   <- mal, y silenciosamente mal

\L y \U de GNU Sed: Modificadores de Mayúsculas Más Cortos

GNU sed añade modificadores de mayúsculas en la parte de reemplazo de s///. \L pone en minúsculas todo lo que sigue, \U pone en mayúsculas todo lo que sigue.

Convertir la línea entera a minúsculas (GNU sed):

echo "HELLO WORLD" | sed 's/.*/\L&/'
# Output: hello world

Convertir la línea entera a mayúsculas (GNU sed):

echo "hello world" | sed 's/.*/\U&/'
# Output: HELLO WORLD

Apuntar a líneas específicas:

sed '/^ERROR/s/.*/\U&/' logfile.txt   # uppercases only lines starting with ERROR

Estos modificadores son solo-GNU. Están ausentes de las man pages de sed de FreeBSD y macOS, así que los scripts que deban correr en un Mac o BSD deben quedarse con y y listas completas. El & en el reemplazo significa “todo el texto coincidente”, por eso s/.*/\L&/ convierte la línea entera.

Una línea sobre locale: LC_ALL=C sed ... da comportamiento ASCII predecible, mientras que \L/\U necesitan un locale UTF-8 para manejar texto no-ASCII. Detalles en la sección de gotchas.

Title Case y Capitalize: \u, \l y \E

Esta es la parte que la mayoría de recopilatorios de “conversión de mayúsculas con sed” se saltan, y es lo que los snippets estilo \b[a-z]\+/\U&/g hacen mal. GNU sed tiene cinco modificadores de mayúsculas en el reemplazo:

Diagrama de los modificadores de mayúsculas de GNU sed actuando sobre texto de ejemplo: backslash L pone en minúsculas el reemplazo, backslash U en mayúsculas, backslash l y backslash u tocan solo el siguiente carácter, y backslash E para la conversión

Title case en cada palabra (primera letra de cada palabra en mayúscula, el resto en minúsculas):

sed -E 's/[a-z]+/\u&/g' filename.txt
# Input:  hello world
# Output: Hello World

Sin -E (BRE), lo mismo:

sed 's/[a-z][a-z]*/\u&/g' filename.txt
# Output: Hello World

Prefiere -E sobre la vieja grafía GNU -r para regex extendida. -E es el flag estándar POSIX hoy en día (bug 528 del Austin Group) y es lo que el propio manual de GNU recomienda para portabilidad.

Poner en mayúscula la primera letra de cada línea:

sed 's/./\u&/' filename.txt
# Input:  hello world
# Output: Hello world

Poner en mayúsculas un token y dejar el resto de la línea igual:

echo "user: admin status: ok" | sed 's/admin/\U&\E/'
# Output: user: ADMIN status: ok

El bug de fuga de \E. La conversión de mayúsculas sigue corriendo por el resto del reemplazo tras un grupo de captura a menos que la pares:

echo "host: db1" | sed -E 's/host: (.*)/HOST: \U\1 is up/'
# Output: HOST: DB1 IS UP   <- "is up" got uppercased too

echo "host: db1" | sed -E 's/host: (.*)/HOST: \U\1\E is up/'
# Output: HOST: DB1 is up   <- \E stops conversion after the group

Dos sutilezas más del manual y de pruebas:

• Con el flag g, la conversión de mayúsculas no se propaga de una coincidencia a la siguiente. Cada coincidencia reinicia limpio. Sí sigue corriendo dentro de un reemplazo a menos que \E la pare.
• Los límites de palabra no son portables. GNU sed acepta \b, \<, \>. El sed tradicional de BSD quiere [[:<:]] y [[:>:]] en su lugar. Si un ejemplo con \b silenciosamente no coincide con nada, normalmente es por eso (vale confirmarlo en tu Mac antes de confiar en cualquiera de las formas).

Coincidir Insensible a Mayúsculas con el Flag I

La conversión de mayúsculas y la coincidencia insensible a mayúsculas resuelven problemas distintos. Cuando quieres encontrar texto sin importar mayúsculas, GNU sed acepta el flag I en coincidencias regex (la i mayúscula también funciona):

sed 's/error/CRITICAL/gI' app.log
# matches Error, ERROR, error, and eRRor

Forma de dirección, por ejemplo borrar cada línea de warning sea cual sea su capitalización:

sed '/^warning/Id' app.log

Sorpresa de portabilidad: I está documentado como extensión GNU, pero el sed de FreeBSD y macOS también acepta i/I como flag de s. Eso lo hace más portable que \L/\U en la práctica. Si solo recuerdas un flag para scripts que viajan entre Linux y macOS, es este.

Convertir Mayúsculas en Archivos: Edición In-Place y Apuntar Patrones

Trabajar con archivos se divide en dos casos: escribir el resultado en otro sitio (seguro), o editar el archivo in-place (rápido, con bordes afilados).

Archivo entero a minúsculas (portable):

sed 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/' filename.txt > output.txt

Archivo entero a minúsculas (GNU sed):

sed 's/.*/\L&/' filename.txt > output.txt

Archivo entero a mayúsculas (portable / GNU):

sed 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/' filename.txt > output.txt
sed 's/.*/\U&/' filename.txt > output.txt

Apuntar a patrones específicos:

sed '/^ERROR/s/.*/\U&/' logfile.txt        # only lines starting with ERROR
sed 's/\blinux\b/\U&/g' filename.txt       # only the word linux (GNU \b)

Ejemplos prácticos:

sed 's/^./\U&/' filename.txt               # uppercase first letter of each line
sed 's/\.[^.]*$/\L&/' filelist.txt         # lowercase the file extension

El ejemplo de la extensión importa: s/\.[A-Z]*$/\L&/ solo coincide con extensiones que ya son todo caps, así que photo.Jpg se escapa. s/\.[^.]*$/\L&/ coincide con cualquier extensión y la pone en minúsculas.

Edición in-place

Prueba el comando sin -i primero. Siempre. Luego edita in-place, y guarda un backup en la primera pasada:

# edit in place
sed -i 's/.*/\L&/' filename.txt

# edit in place and keep a backup copy
sed -i.bak 's/.*/\L&/' filename.txt
ls filename.txt.bak    # confirm the backup exists before you trust this in a loop

# -i REQUIRES a suffix argument on macOS/BSD (empty string = no backup)
sed -i '' 's/.*/\L&/' filename.txt

# cross-platform idiom: GNU treats .bak as a suffix, BSD as a backup extension
sed -i.bak 's/.*/\L&/' filename.txt
ls filename.txt.bak

Verifica antes de seguir:

diff original.txt modified.txt
sed -n '1,5p' filename.txt

Si el archivo está en un repo git, sáltate el desorden de .bak desperdigados y usa comandos git para deshacer cambios en su lugar:

sed -i 's/.*/\L&/' filename.txt
git diff --stat          # see what actually changed
git checkout -- .        # full rollback if the result is wrong

Gotchas de sed -i: macOS, Inodos y Bind Mounts de Docker

GNU sed -i no edita tu archivo. Escribe la salida a un archivo temporal y lo renombra sobre el original. El nombre de archivo se queda; el inodo cambia. Eso tiene consecuencias:

• Los hard links se rompen. Cualquier cosa que aún apunte al inodo viejo ahora tiene contenido rancio.
• tail -f pierde el archivo. Sigue el inodo viejo. tail -F (mayúscula) reabre por nombre y sobrevive.
• Los bind mounts de Docker de un solo archivo fallan. El rename cruza una frontera de montaje y obtienes sed: cannot rename ...: Device or resource busy. Workaround: copia el archivo fuera, edítalo, cópialo de vuelta, o monta el directorio contenedor en vez del archivo suelto. (La redacción exacta del error vale una comprobación de 2 minutos en tu propia versión de Docker; mira los comandos esenciales de Docker para lo básico de montajes.) En contenedores Alpine/BusyBox, sed es BusyBox sed, no GNU sed: -i se comporta algo distinto y no apostaría un deploy a que \L/\U funcionen.
• Necesitas disco libre. Durante la reescritura, la copia temporal existe junto al original. Presupuesta más o menos 2x el tamaño del archivo.
• Race de symlink en GNU sed antiguo. sed -i --follow-symlinks tenía una vulnerabilidad TOCTOU (un symlink intercambiado entre resolución y apertura) arreglada en GNU sed 4.10. Si usas ese flag en directorios compartidos, actualiza.

Conversión de Mayúsculas por Lotes entre Múltiples Archivos

Bucles for, find y xargs cubren casi todos los casos por lotes. Comilla tus variables y maneja espacios en nombres de archivo.

Convertir todos los .txt a minúsculas:

for file in *.txt; do
    sed -i.bak 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/' "$file"
done

La sintaxis de bucle difiere por shell (word splitting, globbing, comportamiento de set -e). Si scripteas esto en algo que no sea bash, mira primero las diferencias entre bash vs zsh vs fish.

Recursivo, seguro-con-espacios:

find . -name "*.txt" -type f -print0 | xargs -0 sed -i.bak 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/'

Find con -exec:

# one sed invocation per file
find . -name "*.txt" -type f -exec sed -i.bak 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/' {} \;

# batched, faster on large trees
find . -name "*.txt" -type f -exec sed -i.bak 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/' {} +

{} + corre sed sobre muchos archivos por invocación y es el default correcto. {} \; es más fácil de leer en la salida de errores, un archivo cada vez.

Procesamiento condicional:

grep -l "ERROR" *.log | xargs sed -i.bak 's/error/ERROR/g'   # only files that contain ERROR
find . -name "*.conf" -exec sed -i.bak '/^#/!s/.*/\L&/' {} \;  # lowercase lines that are not comments

Ejemplos prácticos:

# normalize source files
find ./src -name "*.php" -exec sed -i.bak 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/' {} +

# shout every log level in place
find ./logs -name "*.log" -exec sed -i.bak 's/\b\(info\|warn\|error\|debug\)\b/\U&/g' {} +

Verifica los Resultados tras la Conversión por Lotes

Las ediciones por lotes son donde los bugs silenciosos (como y/A-Z/a-z/) hacen más daño. Verifica en vez de esperar:

# after lowercasing a tree: confirm nothing uppercase remains
grep -rlE '[[:upper:]]' ./converted || echo "clean"

# eyeball the actual changes against the originals
diff -ru ./orig ./converted | head

# in a git repo: summary first, then undo if needed
git diff --stat
git checkout -- .

Gotchas de Conversión de Mayúsculas en Sed (y Arreglos)

Cuatro modos de fallo cubren casi todo reporte de “sed a minúsculas no funciona”.

1. y/A-Z/a-z/ no hace nada útil. y nunca expande rangos ni clases POSIX. Resumen de la sección del comando y: usa las listas completas de 26 caracteres, siempre.

2. La colación del locale se come tus clases de caracteres. [a-z] no es ASCII a a z bajo cada locale. En un locale danés ^[a-z]$ puede coincidir con aa (un símbolo de colación único); los locales españoles hacen cosas parecidas con ll. Si una coincidencia parece imposible o demasiado ansiosa:

LC_ALL=C sed 's/[A-Z]/\l&/g' file.txt     # deterministic ASCII behavior
sed 's/[[:upper:]]/\l&/g' file.txt        # POSIX classes in s/// are locale-aware and explicit

3. Texto Unicode y multibyte. El viejo consejo “sed es solo-ASCII, usa perl” está medio mal:

echo "ÉCOLE École naïve" | LC_ALL=C.UTF-8 sed 's/.*/\L&/'
# Output: école école naïve   <- GNU \L is locale-aware under a UTF-8 locale

echo "ÉCOLE École naïve" | LC_ALL=C sed 's/.*/\L&/'
# mangled multibyte output   <- C locale treats bytes, not characters

echo "ÉCOLE École naïve" | tr '[:upper:]' '[:lower:]'
# Output: École naïve        <- tr is byte-oriented and never touches É

Así que: para Unicode, \L/\U de GNU bajo un locale UTF-8 funciona. tr no. perl y gawk también funcionan si ya los llevas. El comando y es basado en listas e impráctico para Unicode.

4. sed -i intercambia el inodo. Resumen de los gotchas de sed -i: los hard links se rompen, tail -f pierde el archivo, los bind mounts de Docker de un solo archivo pueden fallar en el rename. Si el archivo importa, guarda el backup o el historial de git.

tr vs sed vs awk: ¿Qué Herramienta para Conversión de Mayúsculas?

Benchmark rápido sobre un archivo de 77 MB / 2.000.000 de líneas (GNU sed 4.9, tiempo de reloj; tus números variarán, trátalos como orden de magnitud):

Reglas de dedo, no dogma:

• Volcado de stream entero, nada más - usa tr. Gana en cada trabajo de varios GB.
• Direcciones de línea, patrones o edición in-place - usa sed.
• Lógica de campo o columna (las mayúsculas dependen de qué columna) - usa awk con tolower() / toupper().
• Casos extremos Unicode - \L/\U de GNU bajo un locale UTF-8, o perl / gawk.

Flujo de decisión para herramientas de conversión de mayúsculas: los volcados de stream entero van a tr, el apunte por línea o patrón y la edición in-place van a sed, la lógica de campo va a awk, los casos extremos Unicode van a perl o gawk

Para completar: GNU sed 4.2.2+ tiene sed -z, que lee “líneas” separadas por NUL en vez de separadas por newline. Ese es el truco para entrada multilínea o delimitada por NUL, por ejemplo poner en minúsculas los valores dentro de un stream find -print0 separado por NUL. Y recuerda la nota de disco de antes: el -i in-place necesita más o menos 2x el tamaño del archivo en espacio libre mientras existe la copia temporal.

Chuleta de Cambio de Mayúsculas en Sed

# lowercase, portable (full lists - never y/A-Z/a-z/)
sed 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/' file.txt

# uppercase, portable
sed 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/' file.txt

# lowercase / uppercase, GNU sed
sed 's/.*/\L&/' file.txt
sed 's/.*/\U&/' file.txt

# title case (first letter of each word), GNU sed
sed -E 's/[a-z]+/\u&/g' file.txt

# capitalize first letter of each line
sed 's/./\u&/' file.txt

# uppercase one token, stop conversion with \E
sed 's/admin/\U&\E/' file.txt

# case-insensitive match, then convert
sed 's/error/CRITICAL/gI' app.log

# in-place with backup (GNU + BSD)
sed -i.bak 's/.*/\L&/' file.txt
# macOS/BSD alternative: sed -i '' 's/.*/\L&/' file.txt

# batch, space-safe
find . -name '*.txt' -type f -exec sed -i.bak 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/' {} +

# verify nothing uppercase remains
grep -rlE '[[:upper:]]' . || echo "all lowercase"

FAQ de Cambio de Mayúsculas en Sed