TWikiBaracompanhamentos < TWikiBar

You are here: Wiki-SL>TWikiBar Web>TWikiBaracompanhamentos (28 Feb 2008, CollonsTorre) (raw view)EditAttach
---+!! Acompañamientos para el aperitivo
------
*En construcción para siempre!*
------
Esta página, a pesar de estar dentro del contenido de Conversaciones de Bar, nunca fue publicada en la _Linux Magazine_. Trata de artículos que escribí para otras publicaciones, ayudas útiles que leí navegando por la internet (y en este caso con los debidos créditos), contribuciones de estas personas maravillosas y siempre dispuestas a ayudar del  __Software Libre__, y de la imprescindible <a href="http://br.groups.yahoo.com/group/shell-script/"> "Lista de Shell Script" </a>
------
%TOC%
------

---++ Pasando parámetros con xargs

Existe un comando, cuya función principal es construir listas de parámetros y pasarlas para la ejecución de otros programas o instrucciones. Este comando es el =xargs= y debe ser usado de la siguiente manera:

<verbatim>
    xargs [comando [argumento inicial]]
</verbatim>

En el caso de que el comando (que puede ser inclusive un _script Shell_), sea omitido, será usado por _default_ el =echo=.

El =xargs= combina el argumento inicial con los argumentos recibidos de la entrada patrón, de forma de ejecutar el comando especificado una o más veces.

<kbd>Ejemplo:</kbd>

Vamos a buscar una cadena de caracteres en todos los archivos dentro de un determinado directorio, usaremos el comando =find= con la opción =-type f= para buscar solamente los archivos normales, despreciando directorios, archivos especiales, archivos de uniones, etc, y vamos a hacer la busqueda lo más general posible, recibiendo el nombre del directorio inicial y la cadena a ser buscada como parámetros. Para eso hacemos:

%TERMINAL_INI%
$ cat grepr%OUT_INI%
#
# Grep recursivo
# Busca la cadena de caracteres definida en $2 a partir del directorio $1
#
find $1 -type f -print|xargs grep -l "$2"%OUT_FIM%
%TERMINAL_FIM%

Ejecutando este script buscamos, a partir del directorio definido en la variable =$1=, todos los archivos que contengan la cadena definida en la variable =$2=.

Exactamente lo mismo podría hacerse si la línea del programa fuera la siguiente:

<verbatim>
    find $1 -type f -exec grep -l "$2" {} \;
</verbatim>

El primer proceso tiene dos grandes desventajas sobre el anterior:

   * La primera es bastante visible: el tiempo de ejecución de este método es muy superior al segundo, eso porque el =grep= será hecho en cada archivo que  le sea pasado por el =find=, uno a uno, al paso que con el =xargs=, será pasada toda, o en la peor de las hipótesis, la mayor parte posible, de la lista de archivos generada por el =find=;

   * Dependiendo de la cantidad de archivos encontrados que atiendan al =find=, podemos recibir aquel famoso y fatídico mensaje de error =Too many arguments= indicando una sobrecarga en la pila de ejecución del =grep=. Como fue dicho en el ítem anterior, si usamos el =xargs=, éste pasará hacia el =grep= la mayor cantidad de parámetros posible, suficiente para no causar este error y en caso necesario, ejecutará el =grep= más de una vez. 

%ATENCION_INI%
Atención aquellas personas de linux que usan el =ls= colorido como estándar: en los ejemplos siguientes que incluyen esta instrucción, deben usar la opción =--color=none=, en caso contrario, existen grandes posibilidades de que los resultados no sean los esperados (;-).
%ATENCION_FIM%

Vamos ahora a analizar un ejemplo que es más o menos lo contrario de este que acabamos de ver. Esta vez, vamos a hacer un _script_ para borrar todos los archivos del directorio actual y que pertenezcan a un determinado usuario.

La primera idea que surge es, como en el caso anterior, usar un comando =find=, de la siguiente manera:

<verbatim>
    find . -user cara -exec rm -f {} \;
</verbatim>

Casi estaría correcto, el problema es que de esta forma se estarían borrando no solamente los archivos de =cara= en el directorio actual, sino también de todos los otros sub-directorios "colgados" a éste. Veamos entonces como hacerlo correctamente:

<verbatim>
    ls -l | grep " cara " | cut -c55- | xargs rm
</verbatim>

De esta forma, el =grep= seleccionó los archivos que contenían la cadena =cara= en el directorio actual listado por el =ls -l=. El comando =cut= tomo solamente el nombre de los archivos, pasándolos hacia el borrado, a cargo del =rm= usando el comando =xargs= como puente

El xargs es también una excelente herramienta de creación de _one-liners_ (_scripts_ de solamente una línea). Mira éste para listar todos los propietarios de archivos (inclusive sus _links_) "colgados" en el directorio =/bin= y sus sub-directorios.

%TERMINAL_INI%
$ find /bin -type f -follow | \ 
    xargs ls -al | tr -s ' ' | cut -f3 -d' ' | sort -u
%TERMINAL_FIM%

Muchas veces el =/bin= es un _link_ (si no estoy equivocado, en Solaris es así) y la opción =-follows= obliga al =find= a seguir el _link_. El comando =xargs= alimenta el =ls -al= y la secuencia de comandos siguiente es para tomar solamente el 3er campo (propietario) y clasificarlo devolviendo solamente una vez cada propietario (opción =-u= del comando =sort=, que equivale al comando =uniq=).

---+++ Opciones del xargs
Las opciones del =xargs= pueden se usadas para construir comandos extremamente poderosos. 

---++++ Opción -i

Para ejemplificar esto y comenzar a entender las principales opciones de esta instrucción, vamos a suponer que tenemos que borrar todos los archivos con extensión =.txt= en el directorio actual y presentar sus nombres en pantalla. Veamos que podemos hacer:

%TERMINAL_INI%
$ find . -type f -name "*.txt" | \ 
    xargs -i bash -c "echo borrando {}; rm {}"
%TERMINAL_FIM%

La opción =-i= del =xargs= cambia pares de llaves =({})= por la cadena que está recibiendo a través del pipe =(|)=. Entonces en este caso las llaves =({})= serán cambiadas por los nombres de los archivos que satisfagan al comando =find=.

---++++ Opción -n

Veamos este pequeño juego que vamos a hacer con el =xargs=:

%TERMINAL_INI%
  $ ls | xargs echo > arch.ls
  $ cat arch.ls%OUT_INI%
  arch.ls arch1 arch2 arch3%OUT_FIM%
  $ cat arch.ls | xargs -n1%OUT_INI%
  arch.ls
  arch1
  arch2
  arch3%OUT_FIM%
%TERMINAL_FIM%

Cuando mandamos la salida del =ls= hacia el archivo usando el =xargs= comprobamos lo que ya dijimos, o sea, el =xargs= manda todo lo que sea posible (lo suficiente para no generar una sobrecarga en la pila) de una vez sola. En seguida, usamos la opción =-n 1= para listar uno por uno. Sólo para estar seguros, mira el ejemplo siguiente, donde listaremos dos archivos en cada línea:

%TERMINAL_INI%
$ cat arch.ls | xargs -n 2%OUT_INI%
arch.ls arch1
arch2 arch3%OUT_FIM%
%TERMINAL_FIM%

Sin embargo, la línea de arriba podría (y debería) ser escrita sin usar el _pipe_ =(|)=, de la siguiente forma:

%TERMINAL_INI%
$ xargs -n 2 < arch.ls
%TERMINAL_FIM%

---++++ Opción -p

Otra excelente opción del =xargs= es =-p=, en la cual el sistema pregunta si tu realmente deseas ejecutar el comando. Digamos que en un directorio tengas archivos con la extensión =.bug= y =.ok=, los =.bug= tienen problemas que después de corregidos son grabados como =.ok=. Echa una mirada a la lista de este directorio:

%TERMINAL_INI%
$ ls dir%OUT_INI%
arch1.bug
arch1.ok
arch2.bug
arch2.ok
  ...
arch9.bug
arch9.ok%OUT_FIM%
%TERMINAL_FIM%

Para comparar los archivos buenos con los defectuosos, hacemos:

%TERMINAL_INI%
$ ls | xargs -p -n2 diff -c%OUT_INI%
diff -c arch1.bug arch1.ok ?...y
  ....
diff -c arch9.bug arch9.ok ?...y%OUT_FIM%
%TERMINAL_FIM%

---++++ Opción -t

Para finalizar, el =xargs= también tenemos la opción =-t=, donde va mostrando las instrucciones que montó antes de ejecutarlas. Me gusta mucho esta opción para ayudar a depurar el comando que fue montado.

---++++ Resumen

Entonces podemos resumir el comando de acuerdo con la siguiente tabla:

<center>
%TABLE{ sort="off" tableborder="0" cellpadding="4" cellspacing="1" headerbg="#0000FF" headercolor="#FFFF00" databg="#BBBBBB,#DDDDDD" headerrows="2" footerrows="1" }%
| &nbsp; *Opción* &nbsp; | &nbsp; *Acción*   |
|  =-i=  | &nbsp; Substituye el par de llaves =({})= por las cadenas recibidas &nbsp; |
|  =-nNum=  | &nbsp; Manda el máximo de parámetros recibidos, hasta el máximo de Num para que el comando sea ejecutado &nbsp; |
|  =-lNum=  | &nbsp; Manda el máximo de líneas recibidas, hasta el máximo de Num para que el comando sea ejecutado &nbsp; |
|  =-p=  | &nbsp; Muestra la línea de comando montada y pregunta si desea ejecutarla &nbsp; |
|  =-t=  | &nbsp; Muestra la línea de comando montada antes de ejecutarla &nbsp; |
</center>

---++ Here Strings

Primero un programador con complejo de inferioridad creó el redireccionamiento de entrada y lo representó con un signo de menor =(<)= para representar sus sentimientos. En seguida, otro sintiéndose todavía peor, creó el _here document_ representándolo por dos signos de menor =(<<)= porque su complejo era mayor. El tercero, pensó: "estos dos no saben lo que es estar deprimido"... Entonces creó el _here strings_ representándolo por tres signos de menor =(<<<)=.

Bromas a parte, el _here strings_ es utilísimo y, no sé porque, es un perfecto desconocido. En la poquísima literatura que hay sobre el tema, se nota que el _here strings_ es frecuentemente citado como una variante del _here document_, teoría con la que discrepo pues su aplicabilidad es totalmente diferente de aquella.
Su sintaxis es simple:

<verbatim>
    $ comando <<< $cadena
</verbatim>

Donde =cadena= es expandida y alimenta la entrada primaria (_stdin_) de =comando=.

Como siempre, vamos directo a los ejemplos de los dos usos más comunes para que vosotros mismos saquéis las conclusiones.

   * *Uso #1*. Substituyendo la tan usada construcción =echo "cadeia" | comando=, que obliga a un _fork_, creando un _subshell_ y aumentando el tiempo de ejecución. 

<kbd>Ejemplos:</kbd>

%TERMINAL_INI%
$ a="1 2 3"
$ cut -f 2 -d ' ' <<< $a         # Normalmente se hace: echo $a | cut -f 2 -d ' '%OUT_INI%
2%OUT_FIM%
$ echo $Nomearch%OUT_INI%
Mis Documentos%OUT_FIM%                  # Arrrghhh!
$ tr "A-Z " "a-z_" <<< $Nomearch  # Substituyendo el echo $Nomearch | tr "A-Z " "a-z_"%OUT_INI%
mis_documentos%OUT_FIM%
$ bc <<<"3 * 2"%OUT_INI%
6%OUT_FIM%
$ bc <<<"scale = 4; 22 / 7"%OUT_INI%
3.1428%OUT_FIM%
%TERMINAL_FIM%

Para mostrar la mejoría en el desempeño, vamos a hacer un loop de 500 veces usando el ejemplo dado para el comando =tr=:
Veamos ahora esta secuencia de comandos con medidas de tiempo:

%TERMINAL_INI%
$ time for ((i=1; i<= 500; i++)); { tr "A-Z " "a-z_" <<< $Nomearch >/dev/null; }
%OUT_INI%
real    0m3.508s
user    0m2.400s
sys     0m1.012s%OUT_FIM%
$ time for ((i=1; i<= 500; i++)); { echo $Nomearch | tr "A-Z " "a-z_" >/dev/null; }
%OUT_INI%
real    0m4.144s
user    0m2.684s
sys     0m1.392s%OUT_FIM%
%TERMINAL_FIM%

Veamos ahora esta otra secuencia de comandos con medidas de tiempo:

%TERMINAL_INI%
$ time for ((i=1;i<=100;i++)); { who | cat > /dev/null; }
%OUT_INI%
real    0m1.435s
user    0m1.000s
sys     0m0.380s%OUT_FIM%
$ time for ((i=1;i<=100;i++)); { cat <(who) > /dev/null; }
%OUT_INI%
real    0m1.552s
user    0m1.052s
sys     0m0.448s%OUT_FIM%
$ time for ((i=1;i<=100;i++)); { cat <<< $(who) > /dev/null; }
%OUT_INI%
real    0m1.514s
user    0m1.056s
sys     0m0.412s%OUT_FIM%
%TERMINAL_FIM%

Observando este cuadro verás que en el primero, usamos la forma convencional, en el segundo usamos un _named pipe_ temporal para ejecutar una substitución de procesos y en el tercero usamos _here strings_. Notaras también que al contrario del ejemplo anterior, aqui el uso de _here strings_ no fue lo más veloz. Pero observad también que en este último caso el comando =who= está siendo ejecutado en un _subshell_ y eso aumentó el proceso como un todo.

Veamos una forma rápida de insertar una línea como encabezamiento de un archivo:

%TERMINAL_INI%
$ cat num%OUT_INI%
1       2
3       4
5       6
7       8
9       10%OUT_FIM%
$ cat - num <<< "Impares Pares"%OUT_INI%
Impares Pares
1       2
3       4
5       6
7       8
9       10%OUT_FIM%
%TERMINAL_FIM%

   * *Uso #2*. Otra buena forma  de usar el _here strings_ es juntándolo con un comando =read=, no perdiendo de vista lo que aprendimos sobre =IFS= (<a href="http://twiki.softwarelivre.org/bin/view/TWikiBar/TWikiBarConversa005#Primera_sintáxis_del_comando_for" target="_blank">vedlo aquí, en la explicación del comando for</a>). El comando =cat= con las opciones =-vet= muestra el =&lt;ENTER&gt;= como =$=, el =&lt;TAB&gt;= como =^I= y los otros caracteres de control con la notación =^L= donde =L= es una letra cualquiera. Veamos entonces el contenido de una variable y después vamos a leer cada uno de sus campos:

<kbd>Ejemplos:</kbd>

%TERMINAL_INI%
$ echo "$línea"%OUT_INI%
Leonardo Mello  (21)3313-1329%OUT_FIM%
$ cat -vet <<< "$línea"%OUT_INI%
Leonardo Mello^I(21)3313-1329$%OUT_FIM%     # Los separadores son blanco y &lt;TAB&gt; (^I)
$ read Nom SNom Tel <<< "$línea"
$ echo "${Nom}_$S{Nom}_$Tel"       # Vamos a ver si leyó cada uno de los campos%OUT_INI%
Leonardo_Mello_(21)3313-1329%OUT_FIM%       # Leyó porque los separadores eran iguales al IFS
%TERMINAL_FIM%

También podemos leer directamente de un vector (_array_) vedlo:

%TERMINAL_INI%
$ echo $Frutas%OUT_INI%
Pera:Uva:Manzana%OUT_FIM%
$ IFS=:
$ echo $Frutas%OUT_INI%
Pera Uva Manzana%OUT_FIM%                    # Sin las comillas el shell muestra el IFS como blanco
$ echo "$Frutas"%OUT_INI%
Pera:Uva:Manzana%OUT_FIM%                    # Ahhh, ahora sí!
$ read -a aFrutas <<< "$Frutas"  # La opción -a del read, lee un vector
$ for i in 0 1 2
&gt; do
&gt;     echo ${aFrutas[$i]}        # Imprimiendo cada elemento del vetor
&gt; done%OUT_INI%
Pera
Uva
Manzana%OUT_FIM%
%TERMINAL_FIM%

---++ Rotatório de Tiago

%BIRINAITE_INI%
Estaba, como lo hago todos los días dandole un repaso a los e-mails de la  <a href="http://br.groups.yahoo.com/group/shell-script/"> "Lista de Shell Script" </a>, cuando descubro algo totalmente inusitado de Tiago Barcellos Peczenyj. 

Cuando resolví crear este conjunto de consejos, me acordé de eso y le pedí para que me enviara aquel e-mail nuevamente. El texto siguiente es el e-mail que me mandó, solo inserté el último ejemplo y saqué las abrebiaturas.
%BIRINAITE_FIM%

Julio descubrí una forma en la que el _Shell_ crea combinaciones haciendo rotación con los elementos estipulados. Podemos generar todos los binarios de 0000 a 1111 de la siguiente forma:

%TERMINAL_INI%
$ A={0,1}
$ eval echo $A$A$A$A%OUT_INI%
0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111%OUT_FIM%
%TERMINAL_FIM%

Una aplicación práctica que veo es para combinar valores diferentes sin tener que encadenar _loops_ ni usar el =seq

%TERMINAL_INI%
$ A={`seq -s , -f "_%g" 3`}
$ eval echo -e $A$A$A |tr ' _' '\n ' | grep -vE '.+?(\b[0-9]+\b).+?\1'%OUT_INI%
 1 2 3
 1 3 2
 2 1 3
 2 3 1
 3 1 2
 3 2 1%OUT_FIM%
%TERMINAL_FIM%

En este caso combiné los números de 1 a 3 eliminando repeticiones con el =grep=. usé un =tr= foca'podre' para tratar mejor los datos, saltando línea.
El =grep= es simple como puedes notar, compruebo si una determinada parte de la combinación (=.+?(\b[0-9]+\b).+?=) existe en otra parte (=\1=), si existe, no la dejo imprimir por causa de la opción =-v=, y así
<verbatim>
    1 1 2
    1 2 1
    1 1 1
</verbatim>
no son impresos.

Ahora va mi ejemplo: el one-liner siguiente genererá todos los permisos posibles (en octal) para el archivo =arq= (el ejemplo fué interrumpido por que existen 512 combinaciones de permisos posibles).

%TERMINAL_INI%
$ A={`seq -s , 0 7`}
$ eval echo -e $A$A$A | tr ' ' '\n' | xargs -i bash -c "chmod {} arq; ls -l arq"%OUT_INI%
<nop>---------- 1 julio julio 100 2006-11-27 11:50 arq
<nop>---------x 1 julio julio 100 2006-11-27 11:50 arq
<nop>--------w- 1 julio julio 100 2006-11-27 11:50 arq
<nop>--------wx 1 julio julio 100 2006-11-27 11:50 arq
<nop>-------r-- 1 julio julio 100 2006-11-27 11:50 arq
<nop>-------r-x 1 julio julio 100 2006-11-27 11:50 arq
<nop>-------rw- 1 julio julio 100 2006-11-27 11:50 arq
<nop>-------rwx 1 julio julio 100 2006-11-27 11:50 arq
   . . .   . . .   . . .   . . .   . . .   . . .
<nop>-rwxrwxrw- 1 julio julio 100 2006-11-27 11:50 arq
<nop>-rwxrwxrwx 1 julio julio 100 2006-11-27 11:50 arq%OUT_FIM%
%TERMINAL_FIM%

Veamos este ejemplo paso a paso para entenderlo:

%TERMINAL_INI%
$ echo $A%OUT_INI%
{0,1,2,3,4,5,6,7}%OUT_FIM%
$ eval echo -e $A$A$A%OUT_INI%
000 001 002 003 004 005 006 007 010 ... ... 767 770 771 772 773 774 775 776 777%OUT_FIM%
$ eval echo -e $A$A$A | tr ' ' '\n'%OUT_INI% # El tr cambiará cada espacio en blanco por um &lt;ENTER&gt;
000
001
002
003
. . .
774
775
776
777%OUT_FIM%
%TERMINAL_FIM%

A continuación el =xargs= (<a href="http://twiki.softwarelivre.org/bin/view/TWikiBar/TWikiBaracompanhamentos#Pasando_par%E1metros_con_xargs">clique para consejos sobre el xargs</a>) ejecuta el comando =bash -c= (que sirve para ejecutar una línea de comandos) que por cada vez que se ejecuta  =chmod= y el =ls -l= permite mostrar que los permisos están siendo alterados.

---++  Aritmética en Shell

Antiguamente usábamos el comando <code>expr</code> para hacer operaciones aritméticas y mucha gente aun la usa, pues es compatible con cualquier ambiente. 

<kbd>Ejemplo:</kbd>
%TERMINAL_INI%
$ expr 7 \* 5 / 3    # 7 veces 5 = 35 dividido por 3 = 11%OUT_INI%
14%OUT_FIM%
%TERMINAL_FIM%

En este articulo podremos ver otras formas no tan conocidas, sin embargo más simple de usar, más elaboradas y con mayor precisión.

---+++  El uso de bc
Una forma fantástica de hacer cálculos en Shell &#8211; usada normalmente cuando la expresión aritmética es más compleja, o cuando es necesario trabajar con cifras decimales &#8211; es usar la instrucción de calculo del UNIX/LINUX. El <code>bc</code>. Mira como:


<kbd>Ejemplo:</kbd>
%TERMINAL_INI%
$ echo "(2 + 3) * 5" | bc    # Paréntesis usados para dar preferencia%OUT_INI%
25%OUT_FIM%
%TERMINAL_FIM%

Para trabajar con números reales (números no necesariamente enteros), especifique la precisión (cantidad de decimales) con la opción <code>scale</code> del comando <code>bc</code>. Así veamos el penúltimo ejemplo:


%TERMINAL_INI%
$ echo "scale=2; 7*5/3" | bc%OUT_INI%
11.66%OUT_FIM%
%TERMINAL_FIM%

Otros ejemplos:

%TERMINAL_INI%
$ echo "scale=3; 33.333*3" | bc%OUT_INI%
99.999%OUT_FIM%
$ num=5
$ echo "scale=2; ((3 + 2) * $num + 4) / 3" | bc%OUT_INI%
9.66%OUT_FIM%
%TERMINAL_FIM%

Obviamente todos los ejemplos de arriba en el caso de linux, podrían (y deberían) ser escritos usando _Here Strings_. Veamos los últimos como quedarían:

%TERMINAL_INI%
$ bc <<< "scale=3; 33.333*3"%OUT_INI%
99.999%OUT_FIM%
$ num=5
$ bc <<< "scale=2; ((3 + 2) * $num + 4) / 3"%OUT_INI%
9.66%OUT_FIM%
%TERMINAL_FIM%

Una vez apareció en la lista (excelente a propósito) de Shell script en Yahoo (<a href="http://br.groups.yahoo.com/group/shell-script/"> "Lista de Shell Script" </a>) un persona con la siguiente duda: "yo tengo un archivo cuyos campos están separados por <code><TAB></code> y el tercero de ellos posee números. Como puedo calcular la suma de todos los números de esta columna del archivo?"

Yo envié la respuesta siguiente:

%TERMINAL_INI%
$ echo $(cut -f3 num | tr '\n' +)0 | bc%OUT_INI%
20.1%OUT_FIM%
%TERMINAL_FIM%

Vamos por partes para entenderlo mejor y primero vamos ver como era el archivo que hice para comprobarlo: 

%TERMINAL_INI%
$ cat num%OUT_INI%
a       b       3.2
a       z       4.5
w       e       9.6
q       w       2.8%OUT_FIM%
%TERMINAL_FIM%

Como se puede ver, está dentro del patrón del problema, donde yo tengo como tercer campo números reales. A ver lo que haría la primera parte de la línea de comandos, donde yo transformo los caracteres <code><ENTER></code> (_new-line_) en un señal de más (<code>+</code>):

%TERMINAL_INI%
$ cut -f3 num | tr '\n' +%OUT_INI%
3.2+4.5+9.6+2.8+%OUT_FIM%
%TERMINAL_FIM%

Si yo mandase de esa manera hacia el bc, él me devolvería un error por causa de aquel signo de más (<code>+</code>) suelto al final del texto. Mi solución fue poner un cero al final, pues sumando cero el resultado no se alterará. Veamos entonces como quedó:

%TERMINAL_INI%
$ echo $(cut -f3 num | tr -s '\n' +)0%OUT_INI%
3.2+4.5+9.6+2.8+0%OUT_FIM%
%TERMINAL_FIM%


Eso es lo que se acostumbra llamar _one-liner_, esto es, códigos que serían complicados en otros lenguajes (normalmente sería necesario crear contadores y hacer uno _loop_ de lectura sumando el tercer campo al contador) y en Shell son escritos en una única línea.

Hay también gente que llama eso de método KISS, que es el acrónimo de _Keep It Simple Stupid_. :-)

Pero el uso potencial de esta calculadora no se acaba ahí, existen diversas facilidades proporcionadas por ella. Veamos sólo este ejemplo:

%TERMINAL_INI%
$ echo "obase=16; 11579594" | bc%OUT_INI%
B0B0CA%OUT_FIM%
$ echo "ibase=16; B0B0CA" | bc	    # B, zero, B, zero, C, e A%OUT_INI%
11579594%OUT_FIM%
%TERMINAL_FIM%

En estos ejemplos vimos como hacer cambios de base de numeración con el uso del =bc=. En la primera ponemos la base de salida (=obase=) como =16= (hexadecimal) y en la segunda, dijimos que la base de la entrada (=ibase=) era =10= (decimal).

---+++  Otras formas de trabajar con enteros

Otra forma mucho mejor de hacer cálculos es usar la notación =$((exp aritmética))=. Es bueno estan atento, sin embargo, al hecho de que esta sintaxis no es universal. Bourne Shell (=sh=), por ejemplo, no la reconoce.

<kbd>Ejemplo:</kbd>

Usando el mismo ejemplo que ya habíamos usado:

%TERMINAL_INI%
$ echo $(((2+3)*5))                # Los paréntesis mas internos priorizaran o 2+3%OUT_INI%
25%OUT_FIM%
%TERMINAL_FIM%

Fíjate ahora en esta locura:

%TERMINAL_INI%
$ tres=3
$ echo $(((2+tres)*5))             # Variable tres no precedida por $%OUT_INI%
25%OUT_FIM%
$ echo $(((2+$tres)*5))            # Variable tres precedida por $%OUT_INI%
25%OUT_FIM%
%TERMINAL_FIM%

Ei!! No es el signo (=$=) que la precede lo que caracteriza una variable? Si, pero e todos los sabores UNIX que probé, solo bash o ksh, las dos formas producen una buena aritmética.

Presta atención a esta secuencia:

%TERMINAL_INI%
$ unset i                          # $i mooorreu!
$ echo $((i++))%OUT_INI%
0%OUT_FIM%
$ echo $i%OUT_INI%
1%OUT_FIM%
$ echo $((++i))%OUT_INI%
2%OUT_FIM%
$ echo $i%OUT_INI%
2%OUT_FIM%
%TERMINAL_FIM%

Fíjate que a pesar que la variable no esta definida, pues fue hecho uno =unset= en ella, ninguno de los comandos dió error, porque, como estamos usando construcciones aritméticas, siempre que una variable no existe, es inicializada con cero (=0=).

Fíjate que el =i++= produjo cero (=0=). Esto ocurre porque este tipo de construcción se llama pos-incremento, esto es, primeramente el comando es ejecutado y sólo entonces la variable es incrementada. En el caso del =++i=, fue hecha un pre-incremento: primero incrementó y solo despues el comando fue ejecutado.

También son válidos:

%TERMINAL_INI%
$ echo $((i+=3))%OUT_INI%
5%OUT_FIM%
$ echo $i%OUT_INI%
5%OUT_FIM%
$ echo $((i*=3))%OUT_INI%
15%OUT_FIM%
$ echo $i%OUT_INI%
15%OUT_FIM%
$ echo $((i%=2))%OUT_INI%
1%OUT_FIM%
$ echo $i%OUT_INI%
1%OUT_FIM%
%TERMINAL_FIM%

Estas tres operaciones serian lo mismo que:

<verbatim>
    i=$((i+3))
    i=$((i*3))
    i=$((i%2))
</verbatim>

Y esto seria válido para todos los operadores aritméticos, lo que en resumen produciría la siguiente tabla:

<center>
%TABLE{ sort="off" tableborder="0" cellpadding="4" cellspacing="1" headerbg="#0000FF" headercolor="#FFFF00" databg="#BBBBBB,#DDDDDD" headerrows="2" footerrows="1" }%
|  *Expansión Aritmética*  ||
|  &nbsp; *Expresión* &nbsp;  |  &nbsp; *Resultado* &nbsp;  |
|  =id++ id--=  |&nbsp; pós-incremento y pós-decremento de variables  |
|  =++id -&#8211;id=  |&nbsp; pré-incremento y pré-decremento de variables  |
|  =&#42;&#42;=   |&nbsp; exponenciación  |
|  =&#42; / %=  |&nbsp; multiplicación, división, resto de la división  |
|  =+ -=  |&nbsp; adición, sustracción  |
|  =&#60;&#61; &#62;&#61; &#60; &#62;=  |&nbsp; comparación  |
|  =&#61;&#61; !&#61;=  |&nbsp; igualdad, desigualdad  |
|  =&&=  |&nbsp; And lógico  |
|  =&#124;&#124;=  |&nbsp; Or lógico  |
</center>

Pero el máximo exponente de esta forma de construcción con doble paréntesis es la siguiente:

%TERMINAL_INI%
$ echo $var%OUT_INI%
50%OUT_FIM%
$ var=$((var>40 ? var-40 : var+40))
$ echo $var%OUT_INI%
10%OUT_FIM%
$ var=$((var>40 ? var-40 : var+40))
$ echo $var%OUT_INI%
50%OUT_FIM%
%TERMINAL_FIM%

Este tipo de construcción debe ser usado de la siguiente forma: en caso que la variable =var= sea mayor que =40= (=var>40=), entonces (=?=) hace =var= igual a =var= menos =40= (=var-40=), si no (=:=) hacer =var= igual a =var= más =40= (=var+40=). Lo que quiero decir es que los caracteres punto-de-interrogación (=?=) y dos-puntos (=:=) hacen el papel de "entonces" y "si no", sirviendo así para montar una operación aritmética condicional.

Al igual que usamos la expresión =$((...))= para hacer operaciones aritméticas, también podríamos usar la intrínseca (_built-in_) =let= o construcciónes del tipo =$[...]=.

Los operadores son los mismos para estas tres formas de construcción, lo que varía un poco es la operación aritmética condicional con el uso del =let=. Veamos como sería:

%TERMINAL_INI%
$ echo $var%OUT_INI%
50%OUT_FIM%
$ let var='var>40 ? var-40 : var+40'
$ echo $var%OUT_INI%
10%OUT_FIM%
$ let var='var>40 ? var-40 : var+40'
$ echo $var%OUT_INI%
50%OUT_FIM%
%TERMINAL_FIM%

---+++  Baseando

Si quieres trabajar con bases diferentes de la decimal, basta con usar el formato:

<verbatim>
    base#numero
</verbatim>

Donde =base= es un número decimal entre 2 y 64 en nombre del sistema de numeración, y =numero= es un número en el sistema numérico definido por =base=. Si =base#= fuese omitida, entonces =10= se asume por defecto _default_. Los guarismos mayores que 9 son representados por letras minúsculas, mayúsculas, @ y _, en esta orden.

Si =base= fuese menor o igual a 36, mayúsculas o minúsculas pueden ser usadas indiferentemente para definir guarismos mayores que 9 (no está mal escrito, los guarismos del sistema hexadecimal, por ejemplo, varían entre 0 (cero) y F). Veamos como funciona:

%TERMINAL_INI%
$ echo $[2#11]%OUT_INI%
3%OUT_FIM%
$ echo $((16#a))%OUT_INI%
10%OUT_FIM%
$ echo $((16#A))%OUT_INI%
10%OUT_FIM%
$ echo $((2#11 + 16#a))%OUT_INI%
13%OUT_FIM%
$ echo $[64#a]%OUT_INI%
10%OUT_FIM%
$ echo $[64#A]%OUT_INI%
36%OUT_FIM%
$ echo $((64#@))%OUT_INI%
62%OUT_FIM%
$ echo $((64#_))%OUT_INI%
63%OUT_FIM%
%TERMINAL_FIM%

En estos ejemplos usé las notaciones =$((...))= y =$[...]= indistintamente, para demostrar que ambas funcionan.

Funciona también un cambio automático para la base decimal, si estas usando la convención numérica de C, esto es, en =0xNN=, el =NN= será tratado como un hexadecimal y en =0NN=, el =NN= será visto como uno octal. Vea el ejemplo:

<kbd>Ejemplo</kbd>

%TERMINAL_INI%
$ echo $((10))           # decimal%OUT_INI%
10%OUT_FIM%
$ echo $((010))          # octal%OUT_INI%
8%OUT_FIM%
$ echo $((0x10))         # hexadecimal%OUT_INI%
16%OUT_FIM%
$ echo $((10+010+0x10))  # Decimal + octal + hexadecimal%OUT_INI%
64%OUT_FIM%
%TERMINAL_FIM%

Ah, se me olvidaba! Las expresiones aritméticas con los formatos =$((...)), $[...]= y con el mando =let= usan los mismos operadores usados en la instrucción =expr=, además de los operadores unários (++, --, +=, *=, ...) y condicionales que acabamos de ver.

---++ Pruebas usando expresiones regulares

En las <a href="http://twiki.softwarelivre.org/bin/view/TWikiBar/TWikiBarConversa004" target="_blank">Conversaciones de Bar 004</a>, lo comentamos todo sobre comandos condicionales, pero faltó uno que no existía a aquella época. En esta misma Conversación de Bar, en la sección <a href="http://twiki.softwarelivre.org/bin/view/TWikiBar/TWikiBarConversa004#Y_toma_test" target="_blank"> Y toma de test</a> llegamos a hablar de una construcción del tipo:


<verbatim>
    [[ Expresión ]] && cmd
</verbatim>

Donde el comando =cmd= será ejecutado en el caso que la expresión condicional =Expressión= sea verdadera. Dije que aunque =Expresión= podría ser definida de acuerdo con las reglas de Generación de Nombre de Archivos (_File Name Generation_). A partir del bash versión 3, fue incorporado a esta forma de test un operador representado por ==~=, cuya finalidad es hacer comparaciones con Expresiones Regulares.

<kbd>Ejemplo:</kbd>

%TERMINAL_INI%
$ echo $BASH_VERSION  # Asumiendo que la versión de Bash es igual o superior a la 3.0.0%OUT_INI%
3.2.17(15)-release%OUT_FIM%
$ Cargo=Senador
$ [[ $Cargo =~ ^(Governa|Sena|Verea)dora?$ ]<nop>] && echo É político%OUT_INI%
É político%OUT_FIM%
$ Cargo=Senadora
$ [[ $Cargo =~ ^(Governa|Sena|Verea)dora?$ ]<nop>] && echo É político%OUT_INI%
É político%OUT_FIM%
$ Cargo=Diretor
$ [[ $Cargo =~ ^(Governa|Sena|Verea)dora?$ ]<nop>] && echo É político
$
%TERMINAL_FIM%

Vamos desmenuzar la Expresión Regular =^(Governa|Sena|Verea)dora?$=: esta acepta todo lo que empieza (=^=) por =Governa=, o (=|=) =Sena=, o (=|=) =Verea=, seguido de =dor= y seguido de una =a= opcional (=?=). El signo (=$=) sirve para marcar el fin de la expresión. En otras palabras esta Expresión Regular sera verdadera si recibe una de las siguientes palabras "Governador, Senador, Vereador, Governadora, Senadora e Vereadora". =(En este ejemplo y su explicación hemos omitido la traducción de las constantes para hacer mas comprensible la expresión)=

---++  Coloreando la pantalla

Como usted ya había visto en la <a href="http://twiki.softwarelivre.org/bin/view/TWikiBar/TWikiBarConversa007#El_comando_tput" target="_blank">Conversación de Bar 007</a>, el comando =tput= sirve para hacer casi todo lo referente la formatación de la pantalla, pero lo que no dije es que con él también se pueden usar colores frontales (de los carácteres) y de fondo. Existen también otras formas de hacer lo mismo, creo sin embargo, que la que veremos ahora, es más intuitiva (o menos _&#8220;desintuitiva&#8221;_). La tabla siguiente muestra los comandos para especificar los patrones de colores frontales (_foreground_) o de fondo (_background_):


<center>
%TABLE{ sort="off" tableborder="0" cellpadding="4" cellspacing="1" headerbg="#0000FF" headercolor="#FFFF00" databg="#BBBBBB,#DDDDDD" headerrows="2" footerrows="1" }%
|  *Obteniendo colores con el comando tput*  ||
|  &nbsp; *Comando* &nbsp;  | &nbsp; *Efecto* &nbsp;  |
|  =tput setaf n=  | Especifica =n= como color frontal (_foreground_)   |
|  =tput setab n=  | Especifica =n= como color de fondo (_background_)   |
</center>

Bien, ahora ya sabes como especificar la combinación de colores, pero todavía no sabes los colores. La tabla siguiente muestra los valores que la =n= (de la tabla anterior) debe asumir para cada color:

<center>
%TABLE{ sort="off" tableborder="0" cellpadding="4" cellspacing="1" headerbg="#0000FF" headercolor="#FFFF00" databg="#BBBBBB,#DDDDDD" headerrows="2" footerrows="1" }%
|  *Valores de los colores en el comando tput*  ||
|  &nbsp; *Valor* &nbsp;  | &nbsp; *Color* &nbsp;  |
|  0  | Negro  |
|  1  | Rojo  |
|  2  | Verde  |
|  3  | Marron  |
|  4  | Azul  |
|  5  | Purpura  |
|  6  | Cian  |
|  7  | Gris  |
</center>

En este punto ya puedes empezar a jugar con los colores.

- Pero caramba, todavía son mucho pocos!

- Y, tienes toda la razón... El problema es que todavía no te dije que si pones el terminal en modo de énfasis (=tput bold=), estos colores generan otros ocho. Vamos a mostar entonces la tabla definitiva de los colores:

<center>
%TABLE{ sort="off" tableborder="0" cellpadding="4" cellspacing="1" headerbg="#0000FF" headercolor="#FFFF00" databg="#BBBBBB,#DDDDDD" headerrows="2" footerrows="1" }%
|  *Valores de los colores con el comando tput*  |||
|  &nbsp; *Valor* &nbsp;  | &nbsp; *Color* &nbsp;  | &nbsp; *Color despues de tput bold* &nbsp;  |
|  0  | Negro  | Gris oscuro  |
|  1  | Rojo  | Rojo claro  |
|  2  | Verde | Verde claro  |
|  3  | Marron  | Amarillo  |
|  4  | Azul  | Azul Brillante  |
|  5  | Púrpura  | Rosa  |
|  6  | Ciano  | Ciano claro  |
|  7  | Gris claro  | Blanco  |
</center>

<kbd>Ejemplo</kbd>

Como ejemplo, veamos un _script_ que cambiara el color de la pantalla de acuerdo a tus preferencias.

%TERMINAL_INI%
$ cat mudacor.sh%OUT_INI%
#!/bin/bash
tput sgr0
clear

# Cargando los 8 colores básicos para un vector
Colores=(Negro Rojo Verde Marron Azul Púrpura Cian "Gris claro")

# Listando el menu de colores
echo "
Opc     Cor
===     ==="
#  La siguiente linia significa: para i empezando desde 1;
#+ cuando i es menor o igual al tamaño del vector Colores;
#+ incremente el valor de i de 1 en 1
for ((i=1; i<=${#Cores[@]}; i++))
{
    printf "%02d        %s\n" $i "${Cores[i-1]}"
}

CL=
until [[ $CL <nop>== 0[1-8] || $CL <nop>== [1-8] ]]
do
    read -p "
Escoje el colorr de la letra: " CL
done

#  Para los que tienen un bash a partir de la version 3.2
#+ el test do until de arriba podria hacerse
#+ usando Expresiones Regulares. Veamos como:
#+ until [[ $CL =~ 0?[1-8] ]]
#+ do
#+    read -p "
#+ Escoje el color de la letra: " CL
#+ done

CF=
until [[ $CF <nop>== 0[1-8] || $CF <nop>== [1-8] ]]
do
    read -p "
Escoje el color de Fondo: " CF
done

let CL-- ; let CF--   # Porque los colores varian de cero a siete
tput setaf $CL
tput setab $CF
clear%OUT_FIM%
%TERMINAL_FIM%

---++ Ganando la partida con más comodines

Estaba leyendo mis correos electrónicos cuando recibo uno de Tiago enviado a la <a href="http://br.groups.yahoo.com/group/shell-script/" target="_blank">lista de Shell Script</a> (ya hablé de la lista y de Tiago en el <a href="http://twiki.softwarelivre.org/bin/view/TWikiBar/TWikiBaracompanhamentos#Rotat%F3rio_de_Tiago" target="_blank">Rotatório Peczenyj</a>). Aquí va el contenido del correo electrónico:

No sé si es conocido de todos pero el shell posee, ademas del _globbing_ normal (la expansión =*=, =?= y =[la-z]= de nombres de archivos y directorios), un _globbing_ extendido.

Creo que, en algunos casos, podria ser MUY util, eliminando uno _pipe_ por un =grep= por ejemplo.

Estos son:
<verbatim>
    ?(patron)
</verbatim>
Debe coincidir cero o una ocurrencia de un determinado =patron=
<verbatim>
    *(patron)
</verbatim>
Debe coincidir cero o mas ocurrencias de un determinado =patron=
<verbatim>
    +(patron)
</verbatim>
Debe coincidir una o mas ocurrencias de un determinado =patron=
<verbatim>
    @(patron)
</verbatim>
Debe coincidir con exactamente una ocurrencia de un determinado =patron=
<verbatim>
    !(patron)
</verbatim>
Debe coincidir con cualquier cosa, excepto con =patron=

Para poder utilizár las es necesario ejecutar =shopt= conforme al ejemplo siguiente:

%TERMINAL_INI%
$ shopt -s extglob
$ ls%OUT_INI%
file filename filenamename fileutils%OUT_FIM%
$ ls file?(name)%OUT_INI%
file filename%OUT_FIM%
$ ls file*(name)%OUT_INI%
file filename filenamename%OUT_FIM%
$ ls file+(name)%OUT_INI%
filename filenamename%OUT_FIM%
$ ls file@(name)%OUT_INI%
filename%OUT_FIM%
$ ls file!(name) # divertido esse%OUT_INI%
file filenamename fileutils%OUT_FIM%
$ ls file+(name|utils)%OUT_INI%
filename filenamename fileutils%OUT_FIM%
$ ls file@(name|utils) # "lembra" um {name,utils}%OUT_INI%
filename fileutils%OUT_FIM%
%TERMINAL_FIM%

---++ Usando el awk para buscar por equivalencias

Ahí va una más que Tiago mandó a la <a href="http://br.groups.yahoo.com/group/shell-script/" target="_blank">lista de Shell Script de Yahoo</a> (ya hablé de la lista y de Tiago en el <a href="http://twiki.softwarelivre.org/bin/view/TWikiBar/TWikiBaracompanhamentos#Rotat%F3rio_de_Tiago" target="_blank">Rotatório Peczenyj</a> y en <a href="http://twiki.softwarelivre.org/bin/view/TWikiBar/TWikiBaracompanhamentos#Ganando_la_partida_con_m%E1s_comod target="_blank">Ganando la partida con mas comodines</a>)

Quién no pasó ya por ello: Buscar una palabra, sin embargo una letra acentuada, o no, estorbó la búsqueda?

No descubrí como hacer que el =grep= o el =sed= acepten algo semejante, pero el gawk acepta clases de equivalencia!

Mejor explicar con un ejemplo, donde voy listar el número de la línea y la ocurrencia encontrada:

%TERMINAL_INI%
$ cat dados%OUT_INI%
éco
eco
èco
êco
ëco
eço%OUT_FIM%
$ awk '/^eco/{print NR,$1}' dados%OUT_INI%
2 eco%OUT_FIM%
$ awk '/^e<nop>[<nop>[=c=]]o/{print NR,$1}' dados%OUT_INI%
2 eco
6 eço%OUT_FIM%
$ awk '/^<nop>[<nop>[=e=]]co/{print NR,$1}' dados%OUT_INI%
1 éco
2 eco
3 èco
4 êco
5 ëco%OUT_FIM%
%TERMINAL_FIM%

Es decir, usar <code>[=X=]</code> permite que la expresión encuentre la letra <code>X</code> estando acentuada o no (es sensible a la localización corriente!).

La sintaxis es parecida con la de las clases POSIX, cambiando los dos-puntos =(:)= antes y después de la clase por señales de igual <code>(=)</code>.

Lo creí curioso y debe servir para algún caso semejante al descrito.

---++ find &#8211; Buscando archivo por características

Si estas como el Sr. Magoo, buscando en vano un archivo, usa el mando =find= que sirve para buscar archivos no sólo por el nombre, sino que ademas busca por diversas características. Su sintaxis es la siguiente:

<verbatim>
    find [camino ...] expresión [acción]
</verbatim>

Parametros:

=camino= &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Path del directorio a partir del cual (porque es recursivo, siempre intentará entrar en los subdirectórios "colgados" de este) irá buscando en los archivos;<br>
=expresión= &nbsp;&nbsp;Define los critérios de busqueda. Puede ser una combinación entre vários tipos de busqueda;<br>
=acción= &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Define que acción ejecutar con los archivos que coincidan con los critérios de busqueda definidos por =expresión=.

los principales critérios de busqueda definidos por expresión son:

%TABLE{ sort="off" tableborder="0" cellpadding="0" cellspacing="0" headerbg="#FFFFFF" headercolor="#FFFF00" databg="#FFFFFF" headerrows="0" footerrows="0"}%
| =-name=  | Busca archivos que tengan el nombre especificado. Aquí pueden ser usados metacaracteres o carácteres comodines, sin embargo estos carácteres deberán estar entre comillas, apóstrofos o inmediatamente precedidos por una contrabarra, eso se debe a que quien tienen que expandir los comodines en el =find=. Si fuese el Shell que los expandiese, esto solo se haria con respecto al directorio corriente, lo que echaría por tierra la característica recursiva del =find=;   ||
| =-user=  | Busca archivos que tengan al usuario como propietario;  ||
| =-group=  | Busca archivos que tengan al grupo como propietario;  ||
| =-type&nbsp;c=  | Busca archivos que tengan el tipo =c=, correspondiente a la letra del tipo de archivo. Los tipos aceptados están en la siguiente tabla:  ||
||  __Valores de c__  | __Tipo de archivo buscado__  |
||  =b=  | Archivo especial accedido por el bloque  |
||  =c=  | Archivo especial accedido por el caracter  |
||  =d=  | Directório  |
||  =p=  | _Named pipe_ (FIFO)  |
||  =f=  | Archivo normal  |
||  =l=  | _Link_ simbólico  |
||  =s=  | _Socket_  |
| &nbsp; =-size&nbsp;±n[unid]= &nbsp;  | Busca archivos que usan mas =(+n)= de =n= unidades =unid= de espacio o menos =(-n)= de =n= unidades =unid= de espacio.   ||
||  __Unidades__  | __Valor__  |
||  =b=  | Bloque de 512 _bytes_ (valor _default_)  |
||  =c=  | Caracteres  |
||  =k=  | Kilobytes (1024 _bytes_)  |
||  =w=  | Palabras (2 _bytes_)  |
| =-atime ±d=  | Busca archivos a los que se accedio hace mas =(+d)= de =d= dias o menos =(-d)= de =d= dias;  ||
| =-ctime ±d=  | Busca archivos cuyo status cambio hace mas =(+d)= de =d= dias o menos =(-d)= de =d= dias;  ||
| =-mtime ±d=  | Busca archivos cuyos datos fueron modificados hace mas =(+d)= de =d= dias o menos =(-d)= de =d= dias;  ||

Para usar mas de un critério de busqueda, haz:<br>
&nbsp;&nbsp;&nbsp;&nbsp; =expresión1 expresión2= <br>
o<br>
&nbsp;&nbsp;&nbsp;&nbsp; =expresión1 &#8211;a expresión2= <br>
para atender a los criterios especificados por =expresión1= *y* =expresión2=; <br>
&nbsp;&nbsp;&nbsp;&nbsp; =expresión1 &#8211;o expresión2= <br>
para atender a los criterios especificados por =expresión1= *o* =expresión2=.

Las principales acciones definidas para =acción= son:

%TABLE{ sort="off" tableborder="0" cellpadding="0" cellspacing="0" headerbg="#FFFFFF" headercolor="#FFFF00" databg="#FFFFFF" headerrows="0" footerrows="0"}%
| =-print=  | Esta opción hace que los archivos encontrados sean mostrados en la pantalla. Esta es la opción _default_ en el Linux. En los otros sabores Unix que conozco, si no se especificase ninguna acción, ocurrirá un error;  |
| =-exec&nbsp;cmd&nbsp;{} \;=  | Ejecuta el comando =cmd=. El objetivo del comando es considerado finalizado cuando se encuentra un punto-y-coma =(;)=. La cadena ={}= es substituida por el nombre de cada archivo que satisface al criterio de investigación y la línea así formada es ejecutada. tal y como dijimos para la opción =&#8211;name=, el punto-y-coma =(;)= debe ser precedido por una contrabarra =(\)=, o debe estar entre comillas o apóstrofos; |
| =-ok&nbsp;cmd&nbsp;{} \;= | Lo mismo que el anterior sin embargo pregunta si se puede ejecutar la instrucción =cmd= sobre cada archivo que atiende al criterio de busqueda |
| =-printf&nbsp;formato&nbsp;=  | Permite que se elija los campos que serán listados y formatea la salida de acuerdo con lo especificado en =formato=. |

<kbd> Ejemplos: </kbd>

Para listar en pantalla =(-print)= todos los archivos, a partir del diretório actúal, terminados por =.sh=, haz:

%TERMINAL_INI%
$ find . -name \*.sh	  Acción no especificada &#8211;print el default%OUT_INI%
./undelete.sh	
./ntod.sh%OUT_FIM%	          estos cuatro primeros archivos fueron%OUT_INI%
./dton.sh%OUT_FIM%	          encontrados en el directório actual.%OUT_INI%
./graph.sh
./tstsh/cotafs.sh
./tstsh/data.sh%OUT_FIM%	   Estos cuatro fueron encontrados en el%OUT_INI%
./tstsh/velha.sh%OUT_FIM%	  directório tstsh, bajo el directório corrente%OUT_INI%
./tstsh/charascii.sh%OUT_FIM%
%TERMINAL_FIM%

Necesito obtener espacio en un determinado _file system_ con mucha urgencia, entonces voy a borrar los archivos con más de un megabyte y cuyo último acceso fue hay más de 60 días. Para eso, voy a este _file system_ y hago:

%TERMINAL_INI%
$ find . &#8211;type f &#8211;size +1000000c &#8211;atime +60 &#8211;exec rm {} \;
%TERMINAL_FIM%

Observa que en el ejemplo anterior use tres criterios de búsqueda, a saber:

%TABLE{ sort="off" tableborder="0" cellpadding="0" cellspacing="0" headerbg="#FFFFFF" headercolor="#FFFF00" databg="#FFFFFF" headerrows="0" footerrows="0"}%
| =-type f=  | Todos los archivos regulares (normales)  |
| =-size +1000000c= &nbsp;  | Tamaño mayor de 1000000 de caracteres =(+1000000c)=  |
| =-atime +60=  | Último acesso hace mas de 60 =(+60)= dias.  |

Observa que entre estos tres criterios use el conector __e__, esto es, archivos regulares __e__ mayores que 1MByte __e__ sin acceso hace más de 60 días.

Para listar todos los archivos del disco terminados por =.sh= o =.txt=, haría:

%TERMINAL_INI%
$ find / -name \*.sh &#8211;o &#8211;name \*.txt &#8211;print
%TERMINAL_FIM%

En este ejemplo debemos resaltar además de las contrabarras =(\)= antes de los asteriscos =(*)=, el uso del =&#8211;o= para una u otra extensión y que el directorio inicial era el raíz =(/)=; siendo así, que esta búsqueda se hizo en todo el disco (lo que frecuentemente es bastante lento).

Con el =printf= es posible formatear la salida del comando =find= y especificar los dados deseados. El formateo del =printf= es muy semejante a la del mismo comando en el lenguaje C e interpreta caracteres de formateo precedidos por un símbolo de porcentaje =(%)=. Veamos sus efectos sobre el formateo:

<center>
%TABLE{ sort="off" tableborder="0" cellpadding="4" cellspacing="1" headerbg="#0000FF" headercolor="#FFFF00" databg="#BBBBBB,#DDDDDD" headerrows="2" footerrows="1" }%
|  *Caracter*  |  *Significado*  |
|  =%f=  | Nombree del archivo (el path completo no aparece)  |
|  =%F=  | Indica a que tipo de file system o archivo pertence  |
|  =%g=  | Grupo al cual el archivo pertence  |
|  =%G=  | Grupo al cual el archivo pertence (GID- Numérico)  |
|  =%h=  | Path completo del archivo (todo menos el nombre)  |
|  =%i=  | Número del inode del archivo (en decimal)  |
|  =%m=  | Permisos del archivo (en octal)  |
|  =%p=  | Nombre del archivo  |
|  =%s=  | Tamaño del archivo  |
|  =%u=  | Nombre del usuário (username) propietario del archivo  |
|  =%U=  | Número del usuário (UID) propietario del archivo  |
</center>

También es posible formatear fechas y horas obedeciendo las tablas siguientes:

<center>
%TABLE{ sort="off" tableborder="0" cellpadding="4" cellspacing="1" headerbg="#0000FF" headercolor="#FFFF00" databg="#BBBBBB,#DDDDDD" headerrows="1" footerrows="0" }%
|  *Carácter*  | *Significado*  |
|  =%a=  | Fecha del último acceso  |
|  =%c=  | Fecha de creación  |
|  =%t=  | Fecha de Modificación  |
</center>

Los tres caracteres anteriores producen una fecha semejante a al del comando =date=.

Veamos un ejemplo:

%TERMINAL_INI%
$ find . -name ".b*" -printf '%t %p\n'%OUT_INI%
Mon Nov 29 11:18:51 2004 ./.bash_logout
Tue Nov  1 09:44:16 2005 ./.bash_profile
Tue Nov  1 09:45:28 2005 ./.bashrc
Fri Dec 23 20:32:31 2005 ./.bash_history%OUT_FIM%
%TERMINAL_FIM%

En ese ejemplo, el =%p= fue el responsable por poner los nombres de los archivos. En caso de ser omitido, solamente las fechas serían listadas.
Observe que aunque al final se puso una =/n=. Sin él no habría salto de línea y la lista anterior sería un gran berenjenal.

Esas fechas también pueden ser formateadas, para eso basta pasar las letras de la tabla anterior a mayúsculas (=%La=, =%C= y =%T=) y usar uno de los formateadores de las dos tablas siguientes:

<center>
%TABLE{ sort="off" tableborder="0" cellpadding="4" cellspacing="1" headerbg="#0000FF" headercolor="#FFFF00" databg="#BBBBBB,#DDDDDD" headerrows="2" footerrows="1" }%
|  *Tabla de formatación de tiempo*  ||
|  &nbsp; *Carácter* &nbsp;  | &nbsp; *Significado* &nbsp;  |
|  =H=  | &nbsp;Hora (00..23)  |
|  =I=  | &nbsp;Hora (01..12)  |
|  =k=  | &nbsp;Hora (0..23)  |
|  =l=  | &nbsp;Hora (1..12)  |
|  =M=  | &nbsp;Minuto (00..59)  |
|  =p=  | &nbsp;AM or PM  |
|  =r=  | &nbsp;Horário de 12 horas (hh:mm:ss) seguido de AM o PM  |
|  =S=  | &nbsp;Segundos (00 ... 61)  |
|  =T=  | &nbsp;Horário de 24-horas (hh:mm:ss)  |
|  =Z=  | &nbsp;Huso horário (en mi maravillosa ciudad BRST)  |
</center>

<center>
%TABLE{ sort="off" tableborder="0" cellpadding="4" cellspacing="1" headerbg="#0000FF" headercolor="#FFFF00" databg="#BBBBBB,#DDDDDD" headerrows="2" footerrows="1" }%
|  *Tabla de formatación de fechas*  ||
|  &nbsp; *Carácter* &nbsp;  | &nbsp; *Significado* &nbsp;  |
|  =a=  | &nbsp;Dia de la semana abreviado (Dom...Sab)  |
|  =A=  | &nbsp;Dia de la semana completo (Domingo...Sábado)  |
|  =b=  | &nbsp;Nombre del mes abreviado (Jan...Dez)  |
|  =B=  | &nbsp;Dia del mes completo (Enero...Diciembre)  |
|  =c=  | &nbsp;Fecha y hora completa (Fri Dec 23 15:21:41 2005)  |
|  =d=  | &nbsp;Dia del mes (01...31)  |
|  =D=  | &nbsp;Fecha no formateada mm/dd/aa  |
|  =h=  | &nbsp;Idéntico a b  |
|  =j=  | &nbsp;Dia secuencial del año (001&#8230;366)  |
|  =m=  | &nbsp;Mes (01...12)  |
|  =U=  | &nbsp;Semana secuencial del año. Domingo como 1º dia de la semana (00...53)  |
|  =w=  | &nbsp;Dia secuencial de la semana (0..6)  |
|  =W=  | &nbsp;Semana secuencial del año. Lunes como 1º dia de la semana (00...53)  |
|  =x=  | &nbsp;Representación de la fecha en el formato del país (definido por $LC_ALL)  |
|  =y=  | &nbsp;Año con 2 dígitos (00...99)  |
|  =Y=  | &nbsp;Año con 4 dígitos  |
</center>

Para mejorar la situación, veamos unos ejemplos; sin embargo, veamos primero cuáles son los archivos del directorio corriente que empiezan por =.b=:

%TERMINAL_INI%
$ ls -la .b*%OUT_INI%
-rw-------   1 d276707  ssup        21419 Dec 26 17:35 .bash_history
-rw-r--r--   1 d276707  ssup           24 Nov 29  2004 .bash_logout
-rw-r--r--   1 d276707  ssup          194 Nov  1 09:44 .bash_profile
-rw-r--r--   1 d276707  ssup          142 Nov  1 09:45 .bashrc%OUT_FIM%
%TERMINAL_FIM%

Para listar esos archivos en orden de tamaño, podemos hacer:

%TERMINAL_INI%
$ find . -name ".b*" -printf '%s\t%p\n' | sort -n%OUT_INI%
24      ./.bash_logout
142     ./.bashrc
194     ./.bash_profile
21419   ./.bash_history%OUT_FIM%
%TERMINAL_FIM%

En el ejemplo que acabamos de ver, el =\t= fue substituido por un =<TAB>= a la salida de forma que la lista fuera más legible. Para listar los mismos archivos clasificados por fecha y hora de la última alteración:

%TERMINAL_INI%
$ find . -name ".b*" -printf '%TY-%Tm-%Td %TH:%TM:%TS %p\n' | sort%OUT_INI%
2004-11-29 11:18:51 ./.bash_logout
2005-11-01 09:44:16 ./.bash_profile
2005-11-01 09:45:28 ./.bashrc
2005-12-26 17:35:13 ./.bash_history%OUT_FIM%
%TERMINAL_FIM%


Y no te olvides, cualquer duda o falta de compañia para tomar una cerveza, lo único que tienes que hacer es mandarme un e-mail a <a href="mailto:julio.neves@gmail.com?Subject=Dudas Conversas de bar&#8221;>julio.neves@gmail.com</a>. Voy aprovechar también para mandar mi aviso publicitario: puedes decirle a los amigos que quien quiera hacer un curso nota diez de programación en _Shell_ que mande un e-mail para <a href="mailto:julio.neves@uniriotec.br?Subject=Curso de Shell con Julio Neves">julio.neves@uniriotec.br</a> para informarse. 

Gracias y hasta la próxima!

-- Main.HumbertoPina - 25 Jan 2007
Topic revision: r6 - 28 Feb 2008 - 00:29:35 - CollonsTorre
TWikiBar
Registre-se?
Regras de Formatação
Biblioteca Gráfica?
Carinhas Gráficas
Associação Software Livre.Org - powered by Foswiki
Copyright © by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding Wiki-SL? Send feedback