Tutorial de introducción a Sed: expresiones regulares...
Este artículo es una introducción al uso del editor de flujo Sed en la que te mostraremos ciertas funcionalidades poco conocidas y ejemplos (expresiones regulares, caracteres especiales…) que hacen de Sed una herramienta indispensable para todo usuario de Bash Linux.
¿Qué es el comando Sed y para qué sirve?
El comando Sed es una herramienta de procesamiento de texto en Unix y Linux que se utiliza para realizar operaciones de búsqueda, reemplazo y transformación en archivos de texto. Se utiliza principalmente en scripts de shell y comandos de línea de comandos para manipular y editar contenido de archivos de texto.
¿Cómo usar el comando Sed en Bash Linux?
Para utilizar el comando Sed en Bash Linux, puedes seguir estos pasos:
- Abre una terminal en tu sistema Linux.
- Escribe el comando "sed" seguido de las opciones y argumentos necesarios.
- Especifica el archivo o archivos en los que deseas realizar las operaciones de Sed.
- Añade las operaciones de búsqueda, reemplazo o transformación que deseas realizar utilizando las expresiones regulares adecuadas.
- Ejecuta el comando y verifica los resultados.
¿Cómo funcionan los delimitadores?
- Delimitadores de comandos
De manera predeterminada, este comando utiliza como delimitador para su mecanismo de substitución la barra oblicua / (slash):
sed 's/patrón/reemplazo/' fichero
Para la mayoría de casos, esta opción por defecto resulta suficiente, pero puede resultar un problema si el patrón o la cadena de reemplazo también contiene uno o más slashes como en el caso de la ruta de un archivo. Puedes proteger los slashes poniéndoles un \ (anti-slash o barra oblicua invertida), pero esto resulta una operación muy tediosa si el patrón (o la cadena de reemplazo) contiene varios, volviendo la lectura del código bastante difícil:
sed 's/\/home\/jp\/Docs\/CCM\/SED/\/mnt\/servidor\/docs/' fichero
Puede ser imposible si el patrón (o la cadena de reemplazo) es una variable que debe ser interpretada:
var="/home/jp/Documentos/CCM/SED/" sed 's/'$var'/\/mnt\/servidor\/docs/' fichero
o una expresión entre apóstrofes:
sed "s/$var/\/mnt\/servidor\/docs/" fichero
SED permite reemplazar el delimitador por defecto con un carácter de nuestra elección (#,|,!,§,etc.), siempre y cuando no forme parte del patrón (o la cadena de reemplazo):
sed 's#/home/jp/Docs/CCM/SED#/mnt/servidor/docs#' fichero
Este carácter puede ser cualquier letra siempre y cuando, como hemos mencionado no esté contenida en el patrón (o la cadena de reemplazo):
echo "hola" | sed 'sZbZBZ'
Si utilizas el carácter "!" (signo de exclamación) como separador, debes encerrar la expresión con apóstrofes simples para que el shell no lo interprete (empleado normalmente para gestionar el historial de los comandos).
- Delimitador de patrón
Como hemos visto, Sed utiliza un patrón encerrado entre / (slash) para buscar coincidencias en las líneas de un fichero. El slash utilizado por defecto puede ser cambiado por cualquier otro carácter, simplemente anteponiendo a la primera ocurrencia de este carácter un \ (backslash).
Tomemos el ejemplo de una ruta como criterio de búsqueda. Bajo esta forma, vemos que la lectura del código no es fácil:
sed -n '/\/home\/jp\/Docs\/CCM\/SED/p' fichero
Sin embargo, si utilizamos el carácter almohadilla # como delimitador, tendremos:
sed -n '\#/home/jp/Docs/CCM/SED#p' fichero
¿Cómo funciona el metacarácter '&'?
A menudo el mecanismo de sustitución se limita a buscar un patrón a fin de sustituirlo por sí mismo y agregarle algo. Por ejemplo, buscar la cadena Sed the Stream EDitor en un fichero y agregarle Sed the Stream EDitor (Editor de flujo). Podríamos escribir:
sed 's/Sed the Stream EDitor/Sed the Stream EDitor (Editor de flujo)/g' fichero
El metacaracter "&" (ampersand) nos permite reemplazar todas las cadenas de caracteres que coinciden con el patrón (o la expresión regular) ingresado como primer argumento. Aquí la noción de primer argumento no es muy explícita, pero se verá su importancia con las expresiones regulares y en el apartado de las sub-expresiones. Por lo tanto, nuestro comando se escribirá de esta manera:
sed 's/Sed the Stream EDitor/& (Editor de flujo)/g' fichero
Supongamos que tenemos que buscar todas las cadenas numéricas (una o varias cifras consecutivas) en un fichero y deseamos poner a cada una de estas cadenas ”n°” (observa el espacio después del °). El comando sería este:
sed 's/[0-9][0-9]*/n° &/g' fichero
Necesariamente se debe utilizar la expresión \& para obtener un & literal en una cadena de reemplazo, si no se generarán errores.
¿Cómo usar las subexpresiones y las referencias hacia atrás?
-
Las subexpresiones
\(...\)
Una subexpresión es una parte de una expresión regular, encerrada entre paréntesis, que posteriormente podemos utilizar en la sustitución. Los paréntesis deben ser protegidos con backslashes, a menos que la opción -r haya sido empleada.
- Las referencias hacia atrás
\1 \2 \5
Para referirnos a cada subexpresión en la cadena de reemplazo, utilizamos un número que corresponde a la posición que ocupa en la expresión regular. Este número debe estar protegido por un backslash. Únicamente podemos referirnos a 9 subexpresiones numeradas del \1 al \9. Estas referencias también son llamadas referencias hacia atrás. A continuación, algunos ejemplo con nombres de ciudades francesas y su código postal correspondiente:
- Archivo de referencia:
$ cat plop 31000 Toulouse 34000 Montpellier 66000 Perpignan
En este ejemplo, la subexpresión \([0-9]*\) coincidirá con cualquier cadena numérica y es referenciada por la referencia hacia atrás \1:
$ sed 's/\([0-9]*\).*/\1/' plop 31000 34000 66000
Esta vez buscamos las coincidencias de dos subexpresiones, una numérica y la otra conteniendo el resto de la línea, pero sin incluir el carácter de tabulación que separa el código postal del nombre de la ciudad. Luego utilizamos la referencia hacia atrás \1 (código postal) y \2 (nombre de la ciudad) para mostrar el resultado bajo la forma: nombre de la ciudad > código postal:
$ sed 's/\([0-9]*\)\t\(.*\)/\2 > \1/' plop Toulouse > 31000 Montpellier > 34000 Perpignan > 66000
En este tercer y último ejemplo buscamos las coincidencias de una subexpresión con cada parte de la línea, es decir el código postal (\1), la tabulación (\2) y el nombre de la ciudad (\3):
$ sed 's/\([0-9]*\)\(\t\)\(.*\)/\3\2\1/' plop Toulouse 31000 Montpellier 34000 Perpignan 66000
Una referencia hacia atrás puede llamar a una subexpresión las veces que se desee en la cadena de reemplazo. Retomando el último ejemplo, veamos la demostración con la repetición de la tabulación en diversos lugares:
$ sed 's/\([0-9]*\)\(\t\)\(.*\)/\2\3\2\2\1/' plop
Toulouse 31000
Montpellier 34000
Perpignan 66000
- Expresión regular precedente
Cuando encuentra una coincidencia entre una cadena y una expresión regular, Sed pone en su buffer dicha cadena por lo que es posible referirse a esta cadena en la primera parte del comando de sustitución s (LHS) sin mencionarla literalmente. En otras palabras, un comando del tipo 's//cadena_de_reemplazo/' sustituirá la última expresión regular encontrada por Sed con la cadena_de_reemplazo.
Para ilustrar esto, retomemos nuestro fichero con las ciudades y los códigos postales. Vamos a buscar las líneas que contengan el patrón Montpellier, las otras serán borradas y sustituiremos Montpellier por Béziers:
$ cat plop 31000 Toulouse 34000 Montpellier 64000 Perpignan $ sed '/Montpellier/!d; s//Béziers/' plop 34000 Béziers
Para tratar lo relacionado a las subexpresiones, referencias hacia atrás y expresión regular precedente, el siguiente ejemplo muestra otra faceta de las posibilidades que ofrece Sed. Si el patrón buscado es encerrado entre paréntesis, entonces se convierte en una subexpresión que luego puede ser invocada en la parte derecha del comando s:
sed '/\(Montpellier\)/!d;s//Béziers-\1/' plop 34000 Béziers-Montpellier $ sed '/\(Mon\)tpellier/!d;s//Béziers-\1blanc/' plop 34000 Béziers-Monblanc
¿Cómo usar la negación?
A veces puede ser útil excluir una línea que coincide con un patrón (o un rango de líneas) para que no sea procesada. Para ello, Sed utiliza el carácter "!" (signo de exclamación) que, como en la mayoría de herramientas derivadas de Unix, expresa la negación, exactamente como lo hace el comando grep -v.
Para ello, tan solo hay que poner después del patrón (el número de línea o rango de líneas) el carácter !:
sed -n '3 !p' fich.txt sed -n '3,8 !p' fich.txt sed -n '/indice/! p' fich3.txt
A menudo encontramos en los scripts Sed, la expresión $! que significa ”mientras no se alcance la última línea…” y permite efectuar uno o varios comandos mientras esta condición sea verdadera. Podemos comparar diferentes maneras de escribir la sintaxis de un comando, pero obteniendo un mismo resultado:
echo -e 'a\nb\n\nc\nd\ne\n\nf\ng' | sed '/./! d' echo -e 'a\nb\n\nc\nd\ne\n\nf\ng' | sed '/^$/ d' echo -e 'a\nb\n\nc\nd\ne\n\nf\ng' | sed -n '/^$/! p' echo -e 'a\nb\n\nc\nd\ne\n\nf\ng' | sed -n '/./ p'
¿Cómo se emplea la agrupación de comandos?
/dirección/{...} (Acepta un rango de direcciones.)
Las llaves permiten agrupar comandos que serán ejecutados en una dirección o en un rango de direcciones. Dentro de la agrupación de estos comandos podemos encontrar otras direcciones, así como otros comandos agrupados también entre llaves.
Su principal función es indicar una línea (o rango de líneas) y aplicar sucesivamente uno o varios comandos. El procesamiento es realizado sobre el contenido del buffer y no sobre la línea original, por lo que las modificaciones realizadas pueden condicionar los criterios de selección posteriores:
sed '
/a/{ # solo la línea que contiene "a"
s/a/c/g # reemplazar todas las "a" por "c"
/c/{ # solo la línea que contiene "c" de la línea que coincide
s/c/A/g # reemplazar todas las "c" por "A"
}
}
' < <(echo -e "aaa\nbbb\nccc\nddd")
AAA
bbb
ccc
ddd
$ echo -e "aaa\nbbb\nccc\nddd" | sed '/a/{s/a/c/g;/c/{s/c/A/g}}'
AAA
bbb
ccc
ddd
En un grupo de comandos en un script, cada comando debe iniciar sobre su propia línea, las llaves y el conjunto de comandos deben estar en líneas separadas. La llave que abre debe encontrarse al final de la línea, mientras que la llave que cierra debe necesariamente encontrarse sola en una línea. Atención: no debe haber ningún espacio después de las llaves.
¿Cómo funciona el reemplazo de variables?
Puede darse el caso de que dentro de un script Sed necesitemos pasar una variable como argumento, ya sea como patrón o en una u otra de las partes (LHS o RHS) durante una sustitución. Como mencionamos anteriormente, habrá que prestar atención a los caracteres presentes en la variable a fin de adaptar los apóstrofes a utilizar.
Por defecto Sed utiliza apóstrofes simples para encerrar las expresiones, pero este mecanismo en shell bloquea la expansión de las variables; por lo que el empleo de apóstrofes simples impedirá una buena interpretación de la variable:
var=A; echo 'azerty' | sed 's/a/$var/' $varzerty
Es posible reemplazar estos apóstrofes simples por apóstrofes dobles, lo que en la mayoría de casos será suficiente para permitir la interpretación correcta de la variable:
var=A; echo 'azerty' | sed "s/a/$var/" Azerty
Sin embargo, puede ser más conveniente utilizar esta sintaxis:
var=A; echo 'azerty' | sed 's/a/'"$var"'/' Azerty
En este caso, no es muy fácil comprender por qué es preferible utilizar una mezcla de apóstrofes simples y dobles. En realidad, la palabra "mezcla" no es el término más apropiado, es más apropiado emplear la palabra "excluir", pues con esta sintaxis excluimos la variable de la expresión, lo que permite que sea interpretada por el shell, pero protege dentro de la expresión la interpretación de posibles caracteres propios al shell. Para comprender mejor esto, veamos un ejemplo:
La visualización por el shell de 6 letras del alfabeto, cada una en una línea, en la que la letra A es repetida dos veces. Después de haber asignado esta letra (A) a una variable ($var), vamos a pedir a Sed que no muestre las líneas conteniendo esta variable, empleando la sintaxis incluyendo la negación, es decir el signo de exclamación (!).
- Primero, escribamos la expresión con apóstrofes simples:
var=A; echo -e "A\nB\nC\nA\nD\nE" | sed -n '/$var/!p' A B C A D E
- Observamos que todas las letras son mostradas y la variable no ha sido interpretada por el shell debido a los apóstrofes simples.
- Ahora, pongamos la expresión entre apóstrofes dobles:
var=A; echo -e "A\nB\nC\nA\nD\nE" | sed -n "/$var/!p" -l: !p": event not found
- El shell nos devuelve un mensaje de error “!”. Efectivamente, el ”!” es un carácter reservado del shell que sirve para el historial de los comandos y no ha podido ser interpretado como tal.
- Separemos la variable de la expresión propia a Sed encerrando la expresión justo antes de la variable y volviéndola a abrir justo después utilizando apóstrofes simples. Observa que los apóstrofes dobles alrededor de la variable son opcionales, pero que es preferible dejarlos, ya que es una buena costumbre para prevenir posibles errores debidos a espacios dentro de la variable.
$ var=A; echo -e "A\nB\nC\nA\nD\nE" | sed -n '/'"$var"'/!p' B C D E
¿Cómo usar las expresiones regulares?
El conocimiento de expresiones regulares (regexp) es un plus en la práctica de Sed (y de muchos otros lenguajes). Una expresión regular es un patrón (pattern en inglés) para buscar coincidencias con cadenas de caracteres. La potencia de las expresiones regulares radica en su capacidad de incluir alternativas y repeticiones en la elaboración del patrón. Estas particularidades son elaboradas utilizando caracteres especiales, que no son interpretados literalmente, sino de una manera específica. A continuación una breve descripción de la sintaxis de las expresiones regulares utilizadas en Sed:
- carácter (cualquier carácter): Coincide con un carácter único.
- * Coincide si el carácter o conjunto de caracteres que el precede está presente 0 o más veces. Puede ser un carácter ordinario, un carácter especial protegido por un \, un punto (.), un grupo de expresión regular o una subexpresión.
- \+ Idéntico a *, pero indica que la expresión anterior puede ocurrir una o varias veces.
- \? Idéntico a *, pero indica que la expresión anterior puede ocurrir 0 o 1 vez.
- \{i\} Idéntico a *, pero coincide con exactamente i secuencia de la ocurrencia de la expresión precedente (i representa un entero).
- \{i,j\} Coincide con una secuencia comprendida entre i y j incluyéndolas.
- \{i,\} Coincide con una secuencia mayor o igual a i.
- \(regexp\) Coincide con un conjunto de expresiones regulares, llamado también subexpresión y que puede ser direccionada por referencia hacia atrás (back referente).
- .: Cualquier carácter, excepto una nueva línea.
- ^ Coincide con una cadena nula al inicio de la línea, es decir lo que se encuentra después del acento circunflejo debe aparecer al inicio de línea o al inicio de una subexpresión.
- $ Idéntico a ^ pero la coincidencia es al final de la línea o subexpresión.
- [lista] Coincide con cualquier carácter de la lista. Una lista puede estar constituida por una secuencia de letras como [a-z] lo que equivale a una coincidencia con cualquier carácter comprendido en a y z incluidos. Para incluir un ] hazlo figurar en primera posición en la lista. Para incluir un - ponlo en la primera o última posición de la lista. Para incluir un ^ ponlo después del primer carácter de la lista.
- Por lo general, los caracteres $, *, ., [, y \ no son considerados como caracteres especiales dentro de una lista. De este modo la expresión [\*] corresponderá tanto al carácter \ como al carácter *, el carácter \ no es considerado como un carácter de escape para proteger el carácter *.
- [^lista] A la inversa, un ^ al inicio de lista hará coincidir con cualquier carácter excepto los de la lista. Para incluir un ] hazlo figurar en la primera posición en la lista justo después de el signo ^.
- regexp1\|regexp2 Coincidencia con regexp1 o regexp2. La búsqueda de coincidencias se hace con cada una de las alternativas, de izquierda a derecha y la primera que es encontrada es utilizada. Observa el carácter \ para proteger el carácter |.
- \número Coincide con la enésima subexpresión \ (...\) utilizada en la expresión regular. Las subexpresiones, llamadas también "referencias hacia atrás", son implícitamente numeradas de izquierda a derecha contando el número de ocurrencias de \(, con un máximo de 9.
- \n Coincide con el carácter nueva línea (LF)
- \métacaracter Coincide con un metacaracter entre $, *, ., [, \, o ^, debiendo ser protegido para una interpretación literal.
Nota: en la búsqueda de una coincidencia, esta es efectuada de izquierda a derecha, y si dos o más expresiones tienen el mismo carácter inicial, la coincidencia será hecha con la expresión más larga.
Los caracteres de escape
- \a alarma (campana bip) (BEL, Ctrl-G, 0x07).
- \b borrado hacia atrás (BS, Ctrl-H, 0x08).
- \f fin de página (FF, Ctrl-L, 0x0C).
- \n fin de línea (LF, Ctrl-J, 0x0A).
- \r retorno de carro (CR, Ctrl-M, 0x0D).
- \t tabulación horizontal (HT, Ctrl-I, 0x09).
- \v tabulación vertical (VT, Ctrl-K, 0x0B)
- \o000 carácter cuyo valor en el sistema octal es 000 (de una a tres cifras) [0-7]
- \dDDD carácter cuyo valor en el sistema decimal es DDD (de una a tres cifras) [0-9]
- \xHH carácter cuyo valor en el sistema hexadecimal es HH [0-9A-F]
Otros
- \` coincide con una cadena nula al inicio de la línea (idéntico a ^).
- ' coincide con una cadena nula al final de la línea (idéntico a $).
- \b coincide con una cadena vacía al extremo de una palabra. Denota el límite entre una palabra y un carácter que no sea una palabra.
- \B coincide con una cadena vacía que no se encuentre al extremo de una palabra. Denota el límite entre un carácter, salvo una palabra, y una palabra.
- \w cualquier palabra de la clase: [A-Za-z0-9_] (underscore _ incluido).
- \W cualquier palabra que no pertenezca a la clase: [^A-Za-z0-9_] (underscore _ incluido)
- \s cualquier carácter de espaciado: espacio, tabulación horizontal o vertical.
- \S uno o varios caracteres de espaciado.
- \< coincide con una cadena vacía al inicio de una palabra.
- \> coincide con una cadena vacía al final de una palabra.
- \e fin de conversión de mayúsculas o minúsculas.
- \l conversión del próximo carácter en minúscula.
- \L conversión de los caracteres restantes en minúscula.
- \u conversión del próximo carácter en mayúscula.
- \U conversión de los caracteres restantes en mayúscula.
Las clases de caracteres
- [:alnum:] caracteres alfanuméricos [A-Za-z0-9]
- [:alpha:] caracteres alfabéticos [A-Za-z]
- [:digit:] cifras [0-9]
- [:lower:] caracteres en minúsculas [a-z]
- [:upper:] caracteres en mayúsculas [A-Z]
- [:print:] caracteres imprimibles [ -~]
- [:punct:] caracteres de puntuación [!-/:-@[-`{-~]
- [:space:] espacios, tabulaciones y cualquier carácter vacío [ \t\v\f].
- [:blank:] espacio y tabulación [ \x09].
- [:graph:] cualquier carácter imprimible [!-~] (excepto los espacios vacíos).
- [:cntrl:] caracteres de control [\x00-\x19\x7F].
- [:xdigit:] números hexadecimales [0-9a-fA-F].
¿Qué versiones existen?
Unix
-
GNU sed v4.0.5 (Gsed). Última versión oficial de GNU Sed ofreciendo la edición actual (-i).
-
Ssed v3.60 Descarga. (Small/Stupid Stream EDitor) Versión recomendada
-
BSD multi-byte sed. Versión Japonesa basada en la última versión de GNU Sed.
Windows
-
GnuWin32-Sed v4.1.5 Descargar. La versión ejecutable para MS Windows 95 / 98 / ME / NT / 2000 y XP.
¿Cómo usar los depuradores?
A continuación 2 depuradores que te permitirán comprender mejor el funcionamiento de Sed y en algunos casos te ahorrarán trabajo:
- sdksh y sdshtxt son dos pequeños scripts escritos en Korn shell y Bourne shell respectivamente que incluyen un manual de uso al final del fichero.
- sedsed está escrito en Python (por lo que debe ser instalado en tu sistema) y te permite visualizar el estado del buffer y los comandos interpretados.
A continuación te presentamos un tutorial para el uso de sedsed.
Usage : sedsed OPTION [-e sedscript] [-f sedscriptfile] [inputfile]
OPCIONES:
-f, --file lectura de los comandos desde el fichero indicado
-e, --expression permite encadenar varios comandos
-n, --quiet solicitud implicita para no mostrar el estado de la memoria principal
--silent equivalente a --quiet
-d, --debug activa el modo debug
--hide oculta ciertas opciones de depuración (opciones: PATT,HOLD,COMM)
--color activa la salida del depurador coloreado (activado por defecto)
--nocolor desactiva la salida del depurador coloreado
--dump-debug listado del depurador en la pantalla
-i, --indent indentación del script, un comando por línea
--prefix indentación precedida por espacios o tabulaciones (4 espacios por defecto)
-t, --tokenize modo verbosa, muestra cada comando con más información
-H, --htmlize convierte un script sed en una página HTML coloreada
-V, --version muestra la versión del programa y termina
-h, --help muestra una página de ayuda y termina
- Significado a la salida:
- PATT: Muestra el contenido del espacio patrón (memoria principal).
- HOLD: Muestra el contenido de la memoria secundaria.
- COMM: El comando SED debe ser ejecutado.
- $ Delimita el contenido de PATT y HOLD.
- La sintaxis más común es el modo debug simple (-d):
echo -e "AAA\nBBB\nCCC\nDDD" | sed '/BBB/ {n;s/C/Z/2}'
echo -e "AAA\nBBB\nCCC\nDDD" | sedsed -d '/BBB/ {n;s/C/Z/2}'
- En modo indentación:
sedsed -i -n ':notag;/tag/!{1!H;1h;x;s/\n/ /g;x;$b lastline;d;};/tag/{x;/^$/!p;$b lastline;d;b notag;};:lastline;x;p;'
- Ocultar la visualización de la memoria secundaria:
echo -e "AAA\nBBB\nCCC\nDDD" | sedsed -d --hide=HOLD -n '/BBB/ {n;s/C/Z/2p}'
¿Cuando no debes utilizar Sed?
Cuando ya existen herramientas apropiadas y efectúan la tarea fácilmente y con mayor rapidez, por ejemplo:
- Búsqueda de patrón simple:
grep "patrón" fichero # sed -n "/patrón/p' fichero
- Exclusión de un patrón simple:
grep -v "patrón" fichero # sed "/patrón/!d' fichero
- Búsqueda de patrón y visualización de líneas de contexto antes/después:
grep -A1 -B1 "patón" fichero # sed -n '/patrón/! {x;d;}; /patrón/{x;p;x;p;n;p;x;}' fichero
- Numeración de líneas:
cat -n fichero # sed -e '=' fichero | sed 'N;s/\n/\t/'
nl fichero
- Eliminación de saltos de línea
tr '\n' ' ' < fichero# sed ':bucle; N; $! b bucle; s/\n//g' fichero
- Eliminación de caracteres individuales
tr -d "[w-z]" < fichero # sed 's/[w-z]//g' fichero
- Repetición de caracteres
echo "Booonjoouuur" | tr -s "ou" # echo "Booonjoouuur" | sed 's/oo*/o/g;s/uu*/u/'
- Transposición de caracteres
echo "ABCDEF" | tr "[A-F]" "[a-f]" # echo "ABCDEF" | sed 'y/ABCDEF/abcdef/'
- Formato de ficheros, mejor utilizar los comandos: fold, fmt y par.
Para ciertas tareas que awk y perl realizan mucho más fácil y rápido, como por ejemplo: contar campos y caracteres, contar líneas de un bloque u objetos de un fichero, operaciones matemáticas, calcular la longitud de una cadena, manipular datos binarios, bucles en tablas o listas, etc.
¿Cómo reemplazar y eliminar texto o caracteres con el Sed?
Para reemplazar y eliminar texto o caracteres con el comando Sed, puedes utilizar las siguientes opciones:
- Para reemplazar texto: Utiliza la opción "s/busqueda/reemplazo/g" para buscar y reemplazar todas las ocurrencias de un texto en un archivo.
- Para eliminar texto: Utiliza la opción "d" para eliminar líneas o patrones de texto específicos en un archivo.
Recuerda consultar la documentación y ejemplos adicionales para aprovechar al máximo las capacidades del comando Sed en Bash Linux.
¿Cuáles son los límites de las diferentes versiones?
A continuación, algunos límites conocidos de las versiones distribuidas de Sed, dependiendo del hardware, la memoria, el sistema operativo y de las librerías C utilizadas durante la compilación de Sed.
- Longitud máxima de una línea:
GNU sed: sin limitación
ssed: sin limitación
- Tamaño máximo de la memoria principal y secundaria:
GNU sed: sin limitación
ssed: sin limitación
- Número máximo de ficheros que pueden ser leídos por el comando "r":
GNU sed v3+: sin limitación
ssed: sin limitación
GNU sed v2.05: el total de lecturas (r) y escrituras (w) no debe exceder 32.
- Número máximo de ficheros que pueden ser escritos por el comando "w":
GNU sed v3+: sin limitación
ssed: sin limitación
GNU sed v2.05: el total de lecturas (r) y escrituras (w) no debe exceder 32.
- Tamaño máximo de un nombre de etiqueta
GNU sed: sin limitación
ssed: sin limitación
BSD sed: 8 caracteres
- Tamaño máximo de nombre de fichero en escritura
GNU sed: sin limitación
ssed: sin limitación
BSD sed: 8 caracteres
- Número máximo de conexiones
GNU sed: sin limitación
ssed: sin limitación