Aprenda Linux, 101: Busque archivos de texto usando expresiones regulares

Encontrando agujas en pajares

Aprenda cómo usar expresiones regulares y luego utilícelas para encontrar elementos en archivos de su sistema de archivos. Usted puede usar el material de este artículo para el examen 101 LPI para certificación ® como administrador de sistema Linux, o simplemente por diversión, para aprender.

Ian Shields, Senior Programmer, IBM

Ian ShieldsIan Shields trabaja en múltiples proyectos Linux para la zona Linux developerWorks. Es programador sénior en IBM en Research Triangle Park, NC. Se unió a IBM en Canberra, Australia, como Ingeniero de Sistemas en 1973 y desde entonces ha trabajado en sistemas de comunicaciones e informática ubicua en Montreal, Canadá, y en el RTP, NC. Cuenta con varias patentes y ha publicado bastantes artículos. Su diploma de pre-grado es en matemática pura y filosofía de la Universidad Nacional de Australia. Tiene una maestría y un doctorado en ciencias de la computación de la Universidad Estatal de Carolina del Norte. Aprenda más sobre Ian en el perfil de Ian en My developerWorks.



12-12-2011

Sobre esta serie

Esta serie de artículos le ayuda a aprender tareas de administración de sistema Linux. Usted también puede usar el material en estos artículos para prepararse para los exámenes (LPIC-1) de nivel 1 Linux Professional Institute Certification.

Vea nuestro mapa de ruta de la serie para una descripción de un enlace hacia cada artículo de esta serie. El mapa de ruta está en desarrollo y refleja los últimos objetivos (abril del 2009) para los exámenes LPIC-1: a medida que completemos artículos, los añadiremos al mapa de ruta. Mientras tanto, usted puede encontrar versiones anteriores de material similar , que soporta objetivos LPIC-1 anteriores a abril del 2009, en nuestros tutoriales de preparación para el examen de certificación LPI.

Visión General

Este artículo le proporciona las técnicas básicas Linux para búsqueda de archivos de texto usando expresiones regulares. Aprenda a:

  • Crear expresiones regulares simples
  • Buscar archivos y sistemas de archivos usando expresiones regulares
  • Usar expresiones regulares con sed

Este artículo le ayuda a prepararse para el Objetivo 103.7 del Tema 103 del examen 101 (LPIC-1) Junior Level Administration del Linux Professional Institute. El objetivo tiene un peso de 2.

Prerrequisitos

Para aprovechar al máximo los artículos de esta serie usted debe contar con conocimientos básicos Linux y un sistema Linux funcional en el cual poder practicar los comandos que se cubren en este artículo. Algunas versiones diferentes del programa darán un formato de resultado diferente, por lo que sus resultados pueden no siempre verse igual a los listados y gráficas mostradas aquí. Este artículo construye sobre los conceptos tratados en el artículo anterior "Learn Linux 101: Text streams and filters."


Configurando los ejemplos

Conéctese con Ian

Ian es uno de nuestros autores más prolíficos y populares. Navegue todos los artículos de Ian en developerWorks. Visite el perfil de Ian y conéctese con él, con otros autores y con colegas lectores en My developerWorks.

En este artículo practicaremos los comandos usando algunos de los archivos creados en el artículo "Learn Linux 101: Text streams and filters." En caso de que aún no lo haya hecho o si no grabó los archivos con los que trabajó, puede comenzar creando un nuevo subdirectorio en su directorio objetivo llamado lpi103-7 y creando en este los archivos necesarios. Haga esto abriendo una ventana de texto en su directorio principal como su directorio actual. Luego copie el contenido del Listado uno en la ventana para ejecutar los comandos que crearán el subdirectorio lpi103-7 y los archivos que usted utilizará.

Listado 1. Creando los archivos de ejemplo
mkdir -p lpi103-7 && cd lpi103-7 && {
echo -e "1 apple\n2 pear\n3 banana" > text1
echo -e "9\tplum\n3\tbanana\n10\tapple" > text2
echo "This is a sentence. " !#:* !#:1->text3
split -l 2 text1
split -b 17 text2 y; 
cp text1 text1.bkp
mkdir -p backup
cp text1 backup/text1.bkp.2
}

Su ventana debe verse similar al Listado 2 y su directorio actual ahora debe ser el directorio lpi103-7 creado recientemente.

Listado 2. Creando los archivos de ejemplo -- resultado
ian@attic4:~$ mkdir -p lpi103-7 && cd lpi103-7 && {
> echo -e "1 apple\n2 pear\n3 banana" > text1
> echo -e "9\tplum\n3\tbanana\n10\tapple" > text2
> echo "This is a sentence. " !#:* !#:1->text3
echo "This is a sentence. " "This is a sentence. " "This is a sentence. ">text3
> split -l 2 text1
> split -b 17 text2 y; 
> cp text1 text1.bkp
> mkdir -p backup
> cp text1 backup/text1.bkp.2
> }
ian@attic4:~/lpi103-7$

Expresiones regulares

Las expresiones regulares tienen sus raíces en la teoría de los lenguajes de computación. La mayoría de los estudiantes de ciencias de la computación aprenden que los lenguajes que pueden denotarse por expresiones regulares son precisamente los mismos que los aceptados por autómatas finitos. Las expresiones regulares cubiertas en este artículo son capaces de expresar más complejidad y por ello no son iguales a aquellas que usted puede haber aprendido en clases de ciencias de la computación, aunque la herencia es clara.

Una expresión regular (también conocida como "regex" o "regexp") es una forma de describir una cadena de texto opatrón de forma que un programa pueda hacer coincidir el patrón contra cadenas de texto, proporcionando una capacidad de búsqueda extremadamente potente. El grep (por procesador de generalized regular expression) es una parte estándar de la caja de herramientas de ® herramientas de cualquier programador o administrador Linux o UNIX, permitiendo el uso de expresiones regulares en búsquedas de archivos o resultados de comandos. En el artículo "Learn Linux 101: Text streams and filters," introdujimos sed, el editor de secuencia, que es otra herramienta estándar que usa expresiones regulares extensivamente para encontrar y reemplazar texto en archivos o secuencias de texto. Este artículo le ayuda a entender mejor las expresiones regulares usadas por grep y sed. Otro programa que usa expresiones regulares de forma extensiva es awk.

Como con otras partes de esta serie de artículos, se han escrito libros enteros sobre expresiones regulares y teoría de lenguaje de computadoras. Consulte Recursos para algunas sugerencias.

A medida que usted aprenda sobre expresiones regulares podrá ver las similitudes entre la sintaxis de expresión regular y la sintaxis de comodín (o globbing) tratada en el artículo"Learn Linux 101: File and directory management." La similitud es solo superficial.


Bloques básicos de construcción

Con el programa GNU grep que se encuentra en la mayoría de sistemas Linux se usan dos formas de sintaxis de expresión regular: basic y extended. Con GNU grep, no hay diferencia en su funcionalidad. Aquí se describe la sintaxis básica, junto con las diferencias entre esta y la sintaxis extendida.

Las expresiones regulares se construyen a partir de caracteres y operadores, aumentados por metacaracteres. La mayoría de caracteres coinciden con sí mismos y a la mayoría de metacaracteres deben liberarse usando una barra diagonal invertida (\). Las operaciones fundamentales son:

Concatenación
Concatenar dos expresiones regulares crea una expresión más larga. Por ejemplo, la expresión regular a coincidirá con la cadena de caracteres abcdcba dos veces (la primera y la última a ) e igualmente lo hará la expresión regular b. Sin embargo, ab solo coincidirá abcdcba, mientras que ba solo coincidirá con abcdcba.
Repetición
El operador Kleene * o de repetición coincidirá con cero o más ocurrencias de la expresión regular precedente. Así, una expresión como a*b coincidirá con una cadena de a es terminadas por una b, incluyendo solo la b misma. El Kleene * no necesita ser liberado, por lo que una expresión en la que usted desee hacer coincidir un asterisco literal (*) debe tener el asterisco liberado. El uso de * aquí es diferente del uso de globbing, donde coincide con una cadena de caracteres.
Alternancia
El operador de alternancia (|) coincide con la expresión precedente o con la siguiente. Este debe ser liberado en sintaxis básica. Por ejemplo, la expresión a*\|b*c hará coincidir una cadena de caracteres que consista en cualquier número de a es o cualquier número de bs (pero no ambas) terminadas con una sola c. De nuevo, el carácter individual c coincide.

A menudo usted necesitará encerrar entre comillas sus expresiones regulares para evitar expansión de shell.


Archivos de búsqueda y sistemas de archivos

Usaremos los archivos de texto que usamos antes como ejemplos (vea "Configurando los ejemplos"). Estudie los ejemplos simples del Listado 3. Note que grep toma una expresión regular como parámetro requerido y una lista de cero o más archivos para buscar. Si no se ingresa ningún archivo, grep busca stdin, el cual lo hace un filtro que se puede usar en interconexiones. Si ninguna línea coincide, no hay resultado de grep, aunque se puede probar su código de salida.

Listado 3. Expresiones regulares simples
ian@attic4:~/lpi103-7$ grep p text1
1 apple
2 pear
ian@attic4:~/lpi103-7$ grep pea text1
2 pear
ian@attic4:~/lpi103-7$ grep "p*" text1
1 apple
2 pear
3 banana
ian@attic4:~/lpi103-7$ grep "pp*" text1
1 apple
2 pear
ian@attic4:~/lpi103-7$ grep "x" text1; echo $?
1
ian@attic4:~/lpi103-7$ grep "x*" text1; echo $?
1 apple
2 pear
3 banana
0
ian@attic4:~/lpi103-7$ cat text1 | grep "l\|n"
1 apple
3 banana
ian@attic4:~/lpi103-7$ echo -e "find an \ns* here" | grep "s\*"
s* here

Como puede ver en estos ejemplos, algunas veces usted puede obtener resultados sorprendentes, particularmente con repetición. Tal vez usted esperaba que p* o al menos pp* coincidiera con un par de pes, pero p* y x* también, coinciden con cada línea del archivo porque el operador * coincide con cero o más de la expresión regular precedente.

Dos de los ejemplos ilustran el código de salida de grep. Un valor de 0 es retornado si se encuentra una coincidencia y un valor de 1 si no se encuentra coincidencia. Un valor mayor que 1 (siempre 2 para GNU grep) es retornado en el evento de un error, como la no existencia del archivo que usted está intentando buscar.

Primeros atajos

Ahora que usted puede usar los bloques de construcción básicos de expresiones regulares con grep, aquí están algunos atajos convenientes.

+
El operador + es como el operador *, excepto que este coincide con una o más ocurrencias de la expresión regular precedente. Este debe ser liberado para expresiones básicas.
?
El ? indica que la expresión precedente es opcional, por lo que representa cero o una ocurrencia de esta. Esto no es lo mismo que usar el ? usado en globbing.
.
El . (punto) es un metacarácter que representa a cualquier carácter. Uno de los patrones usados más comúnmente es .*, el cual coincide con una cadena de caracteres de longitud arbitraria que contenga cualquier carácter (o ningún carácter). No es necesario decirlo, pero usted encontrará esta expresión usada como parte de una expresión más extensa. Compare un solo punto con el ? usado en globbing y .* con el * usado en globbing.
Listado 4. Más expresiones regulares
ian@attic4:~/lpi103-7$ grep "pp\+" text1 # at least two p's
1 apple
ian@attic4:~/lpi103-7$ grep "pl\?e" text1
1 apple
2 pear
ian@attic4:~/lpi103-7$ grep "pl\?e" text1 # pe with optional l between
1 apple
2 pear
ian@attic4:~/lpi103-7$ grep "p.*r" text1 # p, some string then r
2 pear
ian@attic4:~/lpi103-7$ grep "a.." text1 # a followed by two other letters
1 apple
3 banana

Haciendo coincidir el comienzo o el fin de la línea

El signo ^ coincide con el comienzo de una línea, mientras que el signo $ coincide con el final de la línea. Así, ^..b coincide con cualquier para de caracteres al comienzo de una línea seguidos por una b, mientras ar$ coincide con cualquier línea que termine en ar. La expresión regular ^$ coincide con una línea vacía.

Más expresiones complejas

Hasta ahora, hemos visto la repetición aplicada a un solo carácter. Si usted desea buscar una o más ocurrencias de una secuencia multicaracter como an que ocurre dos veces en banana, use paréntesis, que deben liberarse en sintaxis básica. De forma similar, tal vez usted desee buscar algunos caracteres sin usar algo tan general como el . o tan extenso como la alternancia. Usted también puede hacer esto encerrando las alternativas en corchetes ([]), los cuales no necesitan liberarse para sintaxis regular. Las expresiones entre corchetes constituyen una clase de carácter. Con algunas excepciones que cubriremos más adelante, el uso de corchetes también elimina la necesidad de liberar caracteres especiales como . y *.

Listado 5. Paréntesis y clases de caracteres
ian@attic4:~/lpi103-7$ grep "\(an\)\+" text1 # find at least 1 an
3 banana
ian@attic4:~/lpi103-7$ grep "an\(an\)\+" text1 # find at least 2 an's
3 banana
ian@attic4:~/lpi103-7$ grep "[3p]" text1 # find p or 3
1 apple
2 pear
3 banana
ian@attic4:~/lpi103-7$ echo -e "find an\ns* here\nsomewhere." | grep "s[.*]"
s* here
ian@attic4:~/lpi103-7$ echo -e "find an\n * in position 2." | grep ".[.*]"
 * in position 2.

Hay muchas otras posibilidades interesantes para clases de caracteres.

Expresión de rango
Una expresión de rango son dos caracteres separados por un - (guión), como 0-9 para dígitos, o 0-9a-fA-F para dígitos hexadecimales. Note que los rangos son dependientes de lo local.
Clases con nombres
Varias clases con nombre proporcionan una taquigrafía conveniente para clases usadas comúnmente. Las clases con nombre se abren con [: y se cierran con :] y pueden ser usadas dentro de expresiones en corchetes. Algunos ejemplos:
[:alnum:]
Caracteres alfanuméricos
[:blank:]
Caracteres de espacio y tabulación
[:digit:]
Los dígitos de 0 hasta 9 (equivalente a 0-9)
[:upper:] y [:lower:]
Letras en mayúscula y minúscula, respectivamente.
^ (negación)
Cuando se usa como el primer carácter después de [ en una clase de carácter, el signo ^ niega el sentido de los caracteres restantes para que la coincidencia ocurra solamente si un carácter (excepto el ^ inicial) no está en la clase.

Dados los significados especiales de arriba, si usted desea hacer coincidir un literal - (guión) dentro de una clase de carácter, debe ponerlo de primero o de último. Si usted desea hacer coincidir un literal ^, este no debe ir primero. Y un ] (corchete derecho) cierra la clase, a menos que se ponga de primero.

Las clases de carácter son un área donde las expresiones regulares y el globbing son similares, aunque la negación difiere (^ vs. !). El Listado 6 muestra algunos ejemplos de clases de caracteres.

Listado 6. Más clases de caracteres
ian@attic4:~/lpi103-7$ # Match on range 3 through 7
ian@attic4:~/lpi103-7$ echo -e "123\n456\n789\n0" | grep "[3-7]"
123
456
789
ian@attic4:~/lpi103-7$ # Find digit followed by no n or r till end of line
ian@attic4:~/lpi103-7$ grep "[[:digit:]][^nr]*$" text1
1 apple
ian@attic4:~/lpi103-7$ # Find a digit, n, or z followed by no n or r till end of line
ian@attic4:~/lpi103-7$ grep "[[:digit:]nz][^nr]*$" text1
1 apple
3 banana

¿Le sorprende el último ejemplo? En este caso, la primera expresión de corchetes coincide con cualquier dígito, n o z en la cadena y la última n no es seguida por otra n o r, de esa manera, lo camino na de la cadena coincide con la expresión regular.

¿Qué coincidió?

Si pudo distinguir el resaltado, como el color, la negrita o el guión inferior, usted puede establecer la variable de entorno GREP_COLORS para resaltar las coincidencias. La configuración predeterminada coincide con la resaltada en negrita roja como se ilustra en la Figura 1. Usted ve que toda la primera línea de resultado coincide, pero solo los dos últimos caracteres de la segunda línea coinciden.

Figura 1. Usando color para coincidencias grep
Usando color para coincidencias grep

Si usted es principiante en cuanto a expresiones regulares, o si no está seguro en cuanto a por qué una línea particular fue retornada por grep, esta técnica puede ayudarle.


Expresiones regulares extendidas

La sintaxis de expresiones regulares extendidas es una extensión GNU. Esta elimina la necesidad de liberar varios caracteres cuando se usan como los hemos usado en sintaxis básica, incluyendo paréntesis, '?', '+', '|' y '{'. Por otro lado, usted debe liberarlos si desea que sean interpretados como caracteres en su expresión regular. Usted puede usar la -E (o la opción --extended-regexp de grep) para señalar que usted está usando sintaxis de expresión regular extendida. De forma alternativa, el comando egrep hace esto para usted. El Listado 7 muestra un ejemplo usado antes en esta sección junto con la expresión extendida correspondiente con egrep.

Listado 7. Expresiones regulares extendidas
ian@attic4:~/lpi103-7$ # Find b followed by one or more an's and then an a
ian@attic4:~/lpi103-7$ grep "b\(an\)\+a" text1 
3 banana
ian@attic4:~/lpi103-7$ egrep "b(an)+a" text1
3 banana

Encontrando elementos en archivos

Ahora que usted tiene control de lo básico, vamos a usar el poder de grep y find para cazar elementos de su sistema de archivos. De nuevo, los ejemplos son relativamente simples; estos usan los archivos creados en un artículo anterior o los que usted creó en el directorio lpi103-7 y en sus hijos. (Vea "Configurando los ejemplos.") Si usted usa archivos del artículo anterior de esta serie, tendrá algunos archivos adicionales y podrá ver algunos resultados adicionales.

Primero, grep puede buscar múltiples archivos al mismo tiempo. Si usted añade la opción -n , esta le dice cuáles números de línea coinciden. Si usted simplemente desea conocer cuántas líneas coincidieron, use la opción -c , y si solo desea una lista de archivos con coincidencias, use la opción -l . El Listado 8 muestra algunos ejemplos.

Listado 8. Grepping multiples archivos
ian@attic4:~/lpi103-7$ grep plum *
text2:9	plum
yaa:9	plum
ian@attic4:~/lpi103-7$ grep -n banana text[1-4]
text1:3:3 banana
text2:2:3	banana
ian@attic4:~/lpi103-7$ grep -c banana text[1-4]
text1:1
text2:1
text3:0
ian@attic4:~/lpi103-7$ grep -l pear *
text1
text1.bkp
xaa

Si usted observa el uso de la opción -c en el Listado 8, verá una línea text3:0. Frecuentemente usted deseará saber cuántas ocurrencias de algo hay en un archivo, pero no deseará saber los archivos que no tengan ninguna ocurrencia de lo que sea que usted está buscando. El comando grep tiene una opción-v , la cual le dice que solo muestre en pantalla el resultado para líneas que no coincidan. Así que podemos usar la expresión regular :0$ para encontrar líneas que terminen en dos puntos y 0.

Nuestro siguiente ejemplo hace esto usando find para ubicar todos los archivos regulares en el directorio actual y sus hijos, y luego usa xargs para pasar la lista de archivos a grep para determinar el número de ocurrencias de banana en cada archivo. Finalmente, este resultado es filtrado mediante otra invocación de grep, esta vez con la opción -v para encontrar todas las líneas que no terminen con :0, dejándonos solo con conteos para archivos que efectivamente puedan contener la cadena de caracteres banana.

Listado 9. Cazando archivos con al menos la cadena banana
ian@attic4:~/lpi103-7$ find . -type f -print0| xargs -0 grep -c banana| grep -v ":0$"
./backup/text1.bkp.2:1
./text2:1
./text1:1
./yaa:1
./xab:1
./text1.bkp:1

Expresiones regulares y sed

La introducción a sed, el Stream Editor, el artículo "Learn Linux 101: Text streams and filters," mencionó que sed usa expresiones regulares. Regexps puede usarse en expresiones de dirección, así como en expresiones de sustitución.

Si usted está buscando algo, entonces probablemente solo use grep. En cambio, si necesita extraer la cadena de caracteres de búsqueda o una cadena relacionada de las líneas que coincidan, y luego manipularla más, usted puede elegir sed . Así que vamos a explorar cómo funciona esto. Recuerde primero que nuestros dos primeros archivos de ejemplo, text1 y text2 contienen un número seguido por un espacio en blanco y luego un nombre de fruta, mientras que text3 contiene una frase repetida. Mostramos el contenido nuevamente en el Listado 10.

Listado 10. Contenido de text1, text2 y text3
ian@attic4:~/lpi103-7$ cat text[1-3]
1 apple
2 pear
3 banana
9	plum
3	banana
10	apple
This is a sentence.  This is a sentence.  This is a sentence.

Primero, usaremos tanto grep como sed para extraer solo las líneas que inician con uno o más dígitos seguidos por caracteres en blanco (espacio o tabulación). Normalmente, sed imprime cada línea al final de un ciclo, así que usaremos la opción -n de sed para suprimir el resultado, y luego usaremos el comandop dentro de sed para imprimir solo las líneas que coinciden con nuestra expresión regular. Para confirmar que usaremos la misma expresión regular para ambas herramientas, la asignaremos a una variable.

Listado 11. Búsqueda usando grep y sed
ian@attic4:~/lpi103-7$ grep "$oursearch" text[1-3]
text1:1 apple
text1:2 pear
text1:3 banana
text2:9	plum
text2:3	banana
text2:10	apple
ian@attic4:~/lpi103-7$ cat text[1-3] | sed -ne "/$oursearch/p"
1 apple
2 pear
3 banana
9	plum
3	banana
10	apple

Note que grep mostrará el nombre de archivo siempre que se busque en más de un archivo. Como usamos cat para proporcionar la entrada para sed, no hay manera de que sed conozca los nombres de archivo originales. No obstante, las líneas coincidentes son idénticas, como esperaríamos.

Ahora supongamos que solo deseamos la segunda palabra de las líneas que encontremos. Es este caso estas serían los nombres de las frutas, pero podríamos estar buscando URLs HTTP o nombres de archivos, o casi cualquier cosa. Para nuestros ejemplos, es suficiente remover exactamente la cadena de caracteres que estuvimos intentando hacer coincidir, así que hagámoslo como se muestra en el Listado 12.

Listado 12. Removiendo los números introductorios con sed
ian@attic4:~/lpi103-7$ cat text[1-3] | sed -ne "/$oursearch/s/$oursearch//p"
apple
pear
banana
plum
banana
apple

Para nuestro ejemplo final, suponga que nuestras líneas pueden tener algo después del nombre de la fruta. Añadiremos una línea que diga "lemon pie" a la mezcla y veremos simplemente cómo eliminar 'lemon'. También ordenaremos el resultado y descartaremos valores que no sean únicos, con lo que obtendremos una lista de las frutas que se encuentren, con cada fruta apareciendo solo una vez.

El Listado 13 muestra dos formas de completar la misma tarea. En la primera, primero retiramos el número introductorio y el espacio en blanco que le sigue, y luego retiraremos cualquier cosa que haya después del primer espacio en blanco o tabulación e imprimiremos lo que quede. En el segundo ejemplo, introduciremos paréntesis para romper toda la línea en tres partes, el número y el espacio que le sigue, la segunda palabra, y todo lo demás. Usamos el comando s para reemplazar toda la línea únicamente con la segunda palabra y luego imprimimos el resultado. Es posible que usted desee intentar una variante de esto omitiendo la tercera parte, \(.*\), y ver si puede explicar lo que sucede.

Listado 13. Llegando al centro de la fruta
ian@attic4:~/lpi103-7$ echo "7 lemon pie" | cat - text[1-3] |
> sed -ne "/$oursearch/s/\($oursearch\)\([^[:blank:]]*\)\(.*\)/\2/p" |
> sort | uniq
apple
banana
lemon
pear

Algunas versiones antiguas de sed no soportan expresiones regulares extendidas. Si su versión de sed soporta regexps extendidas, use la opción -r para decirle a sed que usted está usando sintaxis extendida. El Listado 14 muestra los cambios necesarios para la variableoursearch y los cambios necesarios para que el comando sed haga con expresiones regulares extendidas lo mismo que se estaba haciendo en el Listado 13 con expresiones regulares básicas.

Listado 14. Usando expresiones regulares extendidas con sed
ian@attic4:~/lpi103-7$ echo "7 lemon pie" | cat - text[1-3] |
> sed -nre "/$oursearchx/s/($oursearchx)([^[:blank:]]*)(.*)/\2/p" |
> sort | uniq
apple
banana
lemon
pear
plum

Este artículo solo arañó la superficie de lo que usted puede hacer con la línea de comando Linux usando expresiones regulares con grep y sed. Use las páginas man para aprender más sobre estas valiosas herramientas.

Recursos

Aprender

Obtener los productos y tecnologías

  • Con el software de prueba IBM, disponible para descarga directamente desde developerWorks, construya su próximo proyecto de desarrollo en Linux.

Comentar

Comentarios

developerWorks: Ingrese

Los campos obligatorios están marcados con un asterisco (*).


¿Necesita un IBM ID?
¿Olvidó su IBM ID?


¿Olvidó su Password?
Cambie su Password

Al hacer clic en Enviar, usted está de acuerdo con los términos y condiciones de developerWorks.

 


La primera vez que inicie sesión en developerWorks, se creará un perfil para usted. La información en su propio perfil (nombre, país/región y nombre de la empresa) se muestra al público y acompañará a cualquier contenido que publique, a menos que opte por la opción de ocultar el nombre de su empresa. Puede actualizar su cuenta de IBM en cualquier momento.

Toda la información enviada es segura.

Elija su nombre para mostrar



La primera vez que inicia sesión en developerWorks se crea un perfil para usted, teniendo que elegir un nombre para mostrar en el mismo. Este nombre acompañará el contenido que usted publique en developerWorks.

Por favor elija un nombre de 3 - 31 caracteres. Su nombre de usuario debe ser único en la comunidad developerWorks y debe ser distinto a su dirección de email por motivos de privacidad.

Los campos obligatorios están marcados con un asterisco (*).

(Por favor elija un nombre de 3 - 31 caracteres.)

Al hacer clic en Enviar, usted está de acuerdo con los términos y condiciones de developerWorks.

 


Toda la información enviada es segura.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=90
Zone=Linux
ArticleID=783213
ArticleTitle=Aprenda Linux, 101: Busque archivos de texto usando expresiones regulares
publish-date=12122011