Archive for Enero 2007
Guía rapida de uso de empaquetadores, compresores en linux
Sacado de http://www.badopi.org/node/861
OJO: tar empaqueta varios archivos en uno solo, pero no comprime.
* Ficheros tar
Empaquetar: tar -cvf archivo.tar /dir/a/comprimir/
Desempaquetar: tar -xvf archivo.tar
Ver contenido tar -tf archivo.tar
* Ficheros gz
Comprimir: gzip -9 fichero
Descomprimir: gzip -d fichero.gz
* Ficheros bz2
Comprimir: bzip fichero
Descomprimir: bzip2 -d fichero.bz2
gzip ó bzip2 sólo comprimen ficheros [no directorios, para eso existe tar]. Para comprimir y archivar al mismo tiempo hay que combinar el tar y el gzip o el bzip2 de la siguiente manera:
* Ficheros tar.gz
Comprimir: tar -czfv archivo.tar.gz ficheros
Descomprimir: tar -xzvf archivo.tar.gz
Ver contenido: tar -tzf archivo.tar.gz
* Ficheros tar.bz2
Comprimir: tar -c ficheros | bzip2 > archivo.tar.bz2
Descomprimir: bzip2 -dc archivo.tar.bz2 | tar -xv
Ver contenido: bzip2 -dc archivo.tar.bz2 | tar -t
* Ficheros zip
Comprimir: zip archivo.zip ficheros
Descomprimir: unzip archivo.zip
Ver contenido: unzip -v archivo.zip
* Ficheros lha
Comprimir: lha -a archivo.lha ficheros
Descomprimir: lha -x archivo.lha
Ver contenido: lha -v archivo.lha
Ver contenido: lha -l archivo.lha
* Ficheros arj
Comprimir: arj a archivo.arj ficheros
Descomprimir: unarj archivo.arj
Descomprimir: arj -x archivo.arj
Ver contenido: arj -v archivo.arj
Ver contenido: arj -l archivo.arj
* Ficheros zoo
Comprimir: zoo a archivo.zoo ficheros
Descomprimir: zoo -x archivo.zoo
Ver contenido: zoo -L archivo.zoo
Ver contenido: zoo -v archivo.zoo
* Ficheros rar
Comprimir: rar -a archivo.rar ficheros
Descomprimir: rar -x archivo.rar
Ver contenido: rar -l archivo.rar
Ver contenido: rar -v archivo.rar
Nota del editor (trukulo): Intentad no usar RAR y ARJ que usan formatos propietarios.
1 comment Enero 26, 2007
Código javascript que evitar cargar una página interna de un sistema frames sin el frame padre
if (self.parent.frames.length != 0)
self.parent.location=document.location.href;
Add comment Enero 19, 2007
Diseño de formularios con css
CSS
label,input {
display: block;
width: 150px;
float: left;
margin-bottom: 10px;
}
label {
text-align: right;
width: 75px;
padding-right: 20px;
}
br {
clear: left;
}
HTML
<form> <label for="name">Name</label> <input id="name" name="name"><br> <label for="address">Address</label> <input id="address" name="address"><br> <label for="city">City</label> <input id="city" name="city"><br> </form>
1 comment Enero 19, 2007
Quirk/Hack css para mostrar correctamente min-height en IE y FireFox
Si pongo una altura fija (height) a una capa, en Firefox me cortaría la capa en ese punto, ie no
Para evitar que suceda esto puedo usar min-height.
El problema es que es incompatible con height en Firefox.
El siguiente hack soluciona el problema.
#quickSummary {
/* Para navegadores que respetan los estándares
min-height: 200px;
height: auto;
}
/* Para Internet Explorer */
/*\*/ *
html #quickSummary { height: 200px; }
Add comment Enero 18, 2007
Código javascript que obliga a recargar el frame completo en caso de querer ver una de las ventanas del frame
if (self.parent.frames.length != 0)
self.parent.location=document.location.href;
Add comment Enero 18, 2007
Tutorial básico de Bash sacado de http://www.linux-es.org
Bash (I) – Introducción y ficheros de configuración
Por ralfm
Creado 12/07/2006 – 15:28
En esta serie de articulos sobre el interprete de comandos Bash [1], intentaremos explicar de una manera sencilla como configurar, utilizar y programar en Bash. Existen otros interpretes de comandos totalmente validos y potentes, pero nosotros nos vamos a centrar en Bash por ser el mas usado.
Todo administrador de sistemas UNIX en general y Linux en particular, deberia de aprender un minimo de programacion en Bash para automatizar y administrar tareas y trabajos en el sistema. Las posibilidades som muchas y una vez que se le coge el gusto a este lenguaje de programacion, no te puedes imaginar un dia como administrador sin hacer uso del mismo.
Programar en Bash es facil (aunque a algunos no se lo parezca al principio) y las posibilidades de uso casi infinitas.
Introduccion
Un interprete de comandos es un programa que funciona como interfaz de usuario con el sistema operativo. Es el encargado de traducir los comandos de los usuarios a instrucciones que el sistema operativo pueda entender y viceversa, traducir el resultado devuelto por el sistema operativo a un lenguaje que los usuarios podamos entender.
Bash ha sido escrito por el Proyecto GNU y pertenece a la categoria de interfaz de usuarios en modo caracter o texto.
Este articulo supone que ya teneis Bash instalado en vuestro sistema (por defecto la mayoria de distribuciones instalan y configuran Bash como interprete de comandos del sistema) Para utilizar Bash teneis que usar el sistema en modo texto o abrir una consola de texto en modo grafico.
Como podemos configurar nuestro interprete de comandos
Por defecto, la distribucion que utilicemos configura Bash para que podamos empezar a utilizarlo inmediatamente. Pero si queremos cambiar o añadir otros parametros de configuracion, es bueno saber donde tenemos que hacerlo.
Existen tres ficheros en el directorio de un usuario que tienen un significado especial para el shell Bash. Estos ficheros permiten al usuario configurar el entorno de su cuenta automaticamente cuando entra en el sistema, cuando arranca un subshell o ejecutar comandos cuando sale del sistema.
Los nombres de estos ficheros son .bash_profile, .bashrc y .bash_logout. Si ninguno de estos ficheros existe en el directorio del usuario, /etc/profile es utilizado por el sistema como fichero de configuracion de bash.
.bash_profile es el el mas importante de los tres. Es leido y los comandos incluidos en el, ejecutados, cada vez que el usuario entra en el sistema. Cualquier cambio hecho en este fichero no tendra efecto hasta que salgamos y entremos en el sistema de nuevo. Una alternativa para no tener que salir del sistema es ejecutar el comando source .bash_source.
Bash permite dos sinonimos para este fichero, .bash_login (derivado del C shell) y .profile (derivado del Bourne y Korn shell). Si .bash_profile no existe, el sistema buscara primero .bash_login y luego .profile. Solamente uno de estos ficheros es leido, en el caso que existan simultaneamente.
# Ejemplo de .bash_profile # Get the aliases and functions if [ -f ~/.bashrc ]; then . ~/.bashrc fi # User specific environment and startup programs BASH_ENV=$HOME/.bashrc USERNAME="" PATH=$PATH:/usr/local/pgsql/bin MANPATH=$MANPATH:/usr/local/pgsql/man PGLIB=/usr/local/pgsql/lib PGDATA=/usr/local/pgsql/data export USERNAME BASH_ENV PATH MANPATH PGLIB PGDATA
.bashrc es leido cuando el usuario arranca un subshell, escribiendo por ejemplo bash en la linea de comandos. Esto nos permite ejecutar diferentes comandos para la entrada al sistema o para la ejecucion de un subshell. Si el usuario necesita los mismos comandos tanto a la entrada como en subshells, podemos incluir la siguiente linea en .bash_profile:
source .bashrc
# Ejemplo de .bashrc # User specific aliases and functions alias ll="ls -l --color" alias lal="ls -la --color" alias faq="cd /home/rafael/EL_RINCON/FAQ/" alias php="cd /home/rafael/EL_RINCON/PHP/" # Source global definitions if [ -f /etc/bashrc ]; then . /etc/bashrc fi
.bash_logout es el fichero leido por Bash, cuando salimos del sistema. Podemos definir, por ejemplo que se borren los ficheros temporales creados en nuestra ultima sesion o registrar el tiempo que hemos estado utilizando el sistema. Si .bash_logout no existe, ningun comando sera ejcutado a nuestra salida.
# ejemplo de .bash_logout clear
En la proxima entrega veremos una serie de parametros que podemos utilizar en nuestros ficheros e configuracion y como podemos utilizar una serie de combinaciones especiales de teclas para realizar tareas que nos haran nuestro dias como administradores mucho mas faciles y llevaderos.
Bash (II) – Comandos, variables de entorno y combinaciones de teclas
Por ralfm
Creado 19/08/2006 – 22:57
En este segundo articulo sobre el interprete de comandos bash, vamos a ver tres cosas importantes cuando trabajamos con bash:
- Los comandos y palabras reservadas
- Las variables de entorno
- Combinaciones especiales de teclas
Estas tres cosas nos van a ayudar a trabajar y a escribir scripts y ficheros de configuracion en bash, a conseguir informacion sobre el interprete de comandos y a hacernos nuestro dias como administradores mucho mas faciles y llevaderos (siempre que usemos Bash como nuestro interprete de comandos).
Comandos y palabras reservadas
Aqui tenemos los comandos y palabras reservadas mas importantes que se pueden utilizar con bash, tanto desde scripts como desde la linea de comandos. Mas adelante en esta serie de articulos explicaremos y daremos ejemplos de como usarlos.
Comando Explicacion ----------------------------------------------------------------------------- ! Palabra reservada. Valor logico NOT del codigo de retorno de un comando : No hace nada (expande cualquier argumento) . Lee un fichero y ejecuta su contenido en el interprete de comando actual alias Configura un 'alias' para un comando o linea de comandos bg Pone un trabajo en 'background' bind Asigna una secuencia de teclas a una funcion 'readline' o macro break Sale de un bucle for, select, while o until builtin Ejecuta el interprete de comandos especificado case Palabra reservada. Construccion condicional cd Cambia el directorio de trabajo actual. command Ejecuta un comando sin pasar por la funcion de busqueda del interprete de comandos. continue Salta a la siguiente interacion en un bucle for, select, while o until declare Define variables y les da atributos dirs Muestra la lista actual de directorios recordados disown Remueve un trabajo/proceso de la tabla de trabajod/procesos do Palabra reservada. Parte de un bucle for, select, while o until done Palabra reservada. Parte de un bucle for, select, while o until echo Expande e imprime cualquier argumento elif Palabra reservada. Parte de una construccion if else Palabra reservada. Parte de una construccion if enable Enable and disable built-in shell commands esac Palabra reservada. Parte de una construccion case. eval Ejecuta los argumentos dados a traves de la linea de comandos exec Reemplaza el interprete de comandos con el programa definido exit Sale de el interprete de comandos export Crea variables de entorno fc Edita el fichero con la historia de comandos usados fg Pone un trabajo/proceso en background a foreground fi Palabra reservada. Parte de un construccion if. for Palabra reservada. Bucle de tipo for. function Define una funcion. getopts Procesa opciones de la linea de comandos. hash Rutas de acceso completas son determinadas y recordadas help Muestra informacion sobre comandos embedidos. history Muestra la historia de comandos usados if Palabra reservada. Construccion condicional de tipo if in Palabra reservada. Parte de una construccion condicional de tipo case jobs Muestra una lista con trabajos/procesos ejecutandose en background kill Manda una signal a un proceso let Asigna una variable aritmetica local crea una variable local logout Sale de un interprete de comando de tipo login popd Remueve un directorio del 'stack' de directorios pushd Añade un directorio al 'stack' de directorios pwd Muestra el directorio de trabajo actual. read Lee una linea en el 'standard input' readonly Hace las variable del tipo solo lectura return Retorna de una funcion o script select Palabra reservada. Construccion del tipo generacion de menus. set Define opciones shift Cambia argumentos de la linea de comandos. suspend Suspende la ejecucion de un interprete de comandos. test Evalua una expresion condicional. then Palabra reservada. Parte de una construccion if. time Palabra reservada. Ejecuta un comando y muestra los tiempos de ejecucion. El formato de salida puede ser controlado con TIMEFORMAT times Muestra los tiempos de usuario y sistema acumulados para procesos ejecutados desde el interprete de comandos trap Define una rutina para atrapar una 'signal' type Identifica la fuente de un comando typeset Define variables y les da atributos. Igual que 'declare' ulimit Define/muestra los limites de recursos para los procesos umask Define/muestra la mascara de los permisos de ficheros unalias Remueve definiciones de alias unset Remueve definiciones de variables o funciones until Palabra reservada. Bucle de tipo until wait Espera a que trabajos/procesos en background terminen de ejecutarse while Palabra reservada. Bucle de tipo while
Variables de entorno
A continuacion tenemos la lista de variables reservadas por el interprete de comandos mas comunes. Todas ellas tienen un significado especial para el mismo, algunas de ellas solo se pueden leer, a otras se le asignan ciertos valores automaticamente y algunas pierden su significado si le cambiamos los valores que tienen por defecto.
Variable Explicacion --------------------------------------------------------------------------- CDPATH Una lista de directorios separados por el signo ':' usada como ruta de acceso por el comando cd HOME El directorio principal de usuario IFS Una lista de caracteres para separar campos; usado cuando el interprete de comandos separa palabras como parte de una expansion. MAIL Si este parametro tiene un fichero definido y la variable MAILPATH no esta definida, bash informa al usuario de la llegada de correo al fichero especificado. MAILPATH Una lista de ficheros separada por comas, en los cuales el interprete de comandos comprueba periodicamente de la llegada de correo. OPTARG El valor del ultimo argumento procesado por getopts. OPTIND El indice del ultimo argumento procesado por getopts PATH Una lista de directorios, separados por comas, en los cuales el interprete de comandos busca por comandos PS1 Prompt principal. El valor por defecto es “'s-v$ ' PS2 El prompt secundario. El valor por defecto es '> ' auto_resume Esta variable controla como el interprete de comandos interaciona con el control de usuario y trabajos/procesos BASH La ruta de acceso completa usada para ejecutar la instancia actual de bash BASH_ENV Si esta variable esta definida cuando bash es llamado para ejecutar un script, su valor es expandido y usado como el nombre del fichero leido antes de ejecutar el script. BASH_VERSION El numero de version de bash usada BASH_VERSINFO Una matriz de solo lectura con informacion sobre la version de bash usada. COLUMNS Usada por 'select' para determinar el ancho de la terminal cuando imprime listas de menus. COMP_CWORD Un indice en ${COMP_WORDS} de la palabra conteniendo la posicion del puntero actual COMP_LINE La linea de comando actual COMP_POINT El indice de la posicion relativa del puntero actual con respecto al comienzo del comando actual COMP_WORDS Una matriz con las palabras individuales en la linea de comando actual COMPREPLY Una matriz de donde bash lee las palabras posibles generadas por una funcion del interprete de comandos usada por la utilidad de generacion de terminos posibles. DIRSTACK Una matriz que contiene los contenidos actuales del stack de directorios EUID El identificador numerico de usuario del usuario actual FCEDIT El editor usado por defecto por la opcion -e del comando 'fc' FIGNORE Una lista separada por comas de sufijos a ignorar cuando se efectua la generacion de posibles nombres de ficheros. FUNCNAME El nombre de la funcion que se esta ejecutando actual GLOBIGNORE Una lista separada por comas de los patrones que definen el conjunto de nombres de ficheros a ignorar cuando se efectua la generacion de posibles nombres GROUPS Una matriz que contiene la lista de los grupos a que pertenece el usuario actual HISTCMD El indice del comando actual en la historia de comandos HISTCONTROL Define si un comando es ańadido a la historia de comandos HISTFILE El nombre del fichero en el cual se graba la historia de comandos de comandos. El valor por defecto es ~/.bash_history HISTFILESIZE El numero maximo de lineas contenidas en la historia de comandos, por defecto 500 HISTIGNORE Una lista separada por comas de los patrones usados para definir que comandos deben de grabarse en la historia de comandos HISTSIZE El maximo numero de comandos a recordar en la historia de comandos, por defecto 500 HOSTFILE Contiene el nombre de un fichero en el mismo formato que /etc/hosts que deberia de usarse cuando el interprete de comandos necesita completar un nombre de maquina (hostname) HOSTNAME El nombre de maquina actual HOSTTYPE Cadena describiendo la maquina que esta ejecutando Bash IGNOREEOF Controla la accion a tomar cuando el interprete de comandos recibe un caracter EOF INPUTRC Nombre del fichero de inicializacion de 'Readline', sobreescribiendo el valor por defecto /etc/inputrc. LINES Usada para determinar la anchura de la columna usada para imprimir listas MACHTYPE Cadena describiendo el tipo de sistema que esta ejecutando Bash MAILCHECK Frecuencia de comprobacion (en segundos) del correo electronico en el fichero definido en las variables MAILPATH o MAIL OLDPWD Directorio previo definido por el comando 'cd' OSTYPE Cadena describiendo el sistema operativo que esta ejecutando Bash PPID El numero de proceso del proceso padre del interprete de comandos PS3 El valor de esta variable se usa como 'prompt' PWD Directorio actual definido por el comando 'cd' RANDOM Cuando se llama esta variable un numero entero entre 0 32767 es generado SECONDS Numero de segundos desde que Bash fue arrancado SHELLOPTS Lista con opciones de Bash activadas UID El valor numerico real del usuario actual
Combinaciones especiales de teclas
Cuando usamos bash existen una serie de combinaciones de teclas que se pueden utilizar para editar y realizar operaciones usuales.
Existen dos modos de edicion, mode emacs y modo vi. El modo por defecto es emacs, pero para los que estan acostumbrados a utilizar el editor ‘vi’, no es dificil cambiar entre los modos.
Para cambiar de modos podeis ejecutar estos comandos:
$ set -o emacs $ set -o vi
Nosotros nos vamos a centrar en el modo de edicion emacs, al ser el modo por defecto y el mas usado. A continuacion teneis las combinaciones mas usuales (aunque no son las unicas):
Para moverse por la linea de comandos:
Ctrl + A Ir al principio de linea Ctrl + E Ir al final de linea ESC + B Ir una palabra hacia atras ESC + F Ir una palabra hacia adelante Ctrl + B Ir una letra hacia atras Ctrl + F Ir una letra hacia adelante
Para moverse por el historial de comandos ejecutados:
Ctrl + N Proxima linea en el historial Ctrl + P Previa linea en el historial Ctrl + R Busqueda atras en el historial Ctrl + S Busqueda adelante en el historial
Para borrar parte de la linea de comandos:
Ctrl + U Borra de la posicion actual al principio de la linea Ctrl + K Borra de la posicion actual al final de la linea Ctrl + W Borra de la posicion actual al principio de la palabra ESC + D Borra de la posicion actual al final de la palabra Ctrl + D Borra el caracter actual hacia adelante Ctrl + Y Deshace el ultimo borrado
Transformaciones:
Ctrl + T Intercambiar dos letras ESC + C Cambiar a mayuscula la primera letra de la primera palabra despues de la posicion actual ESC + L Cambiar a minusculas la primera palabra despues de la posicion actual ESC + T Intercambiar dos palabras ESC + U Cambiar a mayusculas la primera palabra despues de la posicion actual TAB + TAB Autocompleta palabras (comandos, ficheros, directorios, variables etc) con posibles valores
En nuestra proxima entrega empezaremos a ver como usar la informacion de este articulo para trabajar con bash y empezar a escribir nuestros primeros scripts.
Bash (III) – Variables y funciones
Por ralfm
Creado 03/09/2006 – 10:34
En nuestra tercera entrega sobre el interprete de comandos Bash vamos a empezar a ver como podemos usar de forma practica la informacion que hemos visto en los articulos anteriores. Para empezar y antes de entrar en materia, nada mejor que un ejemplo del clasico “Hola Mundo” [1] en Bash.
#!/bin/bash # # Esto es un ejemplo en Bash del clasico "Hola Mundo" # echo "Hola Mundo"
Como podeis ver, nada dificil para empezar. Empecemos a explicar un poco que significa cada linea:
#!/bin/bash: Esta linea indica donde se encuentra el interprete de comandos en nuestro sistema. Por defecto todos los sistemas que tengan Bash instalado, lo tendran en el directorio /bin. Al utilizar esta linea, podremos ejecutar el script como un programa normal, ya que el sistema sabra que es un script en Bash y que tiene que hacer con el.
Si el script de ejemplo lo hubiesemos grabado como ejemplo.sh, lo podriamos ejecutar de la siguiente manera:
[ralfm@desktop]# chmod ugo+x ejemplo.sh [ralfm@desktop]# ./ejemplo.sh Hola Mundo
# Esto es un ejemplo en Bash del clasico “Hola Mundo”: Esto es un comentario. Todas las lineas que empiecen con el simbolo ‘#’ seran tratadas como comentarios y no se ejecutaran.
echo “Hola Mundo”: Esto es el comando que imprime la cadena de texto en pantalla.
Variables
En todo script tendreis que trabajar con variables, mas tarde o mas temprano. Vamos a ver como se definen y usan. Una buena costumbre cuando definamos variables en Bash es utilizar letras mayusculas, esto no es necesario, pero nos ayudara a tener un script mas facil de entender.
Definiendo una variable
#!/bin/bash # # Esto es un ejemplo en Bash del clasico "Hola Mundo" # MENSAJE="Hola Mundo" echo $MENSAJE
Hemos definido una variable llamada MENSAJE con el valor “Hola Mundo”, y la hemos usado con el comando echo para escribir el valor de la misma. Las variables en Bash se definen como NOMBRE=valor (sin espacios antes o despues del simbolo ‘=’) y su valor se usa, poniendo el simbolo ‘$’ delante del nombre de la variable, $NOMBRE.
Si al utilizar el valor de una variable, el nombre de variable esta seguido de un caracter que sea otra letra, numero o el simbolo ‘_’, tendremos que utilizar los simbolos ‘{}’ alrededor del nombre de la variable.
#!/bin/bash FICHERO="registro" echo ${FICHERO}_2006.txt
Usando variables de entorno
#!/bin/bash echo "El usuario '$USERNAME' ha ejecutado el script $0, en el ordenador '$HOSTNAME'. "
Tambien se pueden usar en nuestro scripts, variables que no hemos definido nosotros. Estas variables son las llamadas ‘variables de entorno’ del sistema. Teneis una lista con las mas importantes por defecto, en el segundo articulo de esta serie, Bash (II) – Comandos, variables de entorno y combinaciones de teclas [2]. En nuestro ejemplo hemos utilizado $USERNAME y $HOSTNAME para obtener el nombre de usuario y del ordenador. La variable $0 contiene el nombre del script, mas adelante explicaremos esto.
Asignado resultados de comandos a variables
#!/bin/bash ATRIBUTOS_SCRIPT=`/bin/ls -l $0` echo "El usuario '$USERNAME' ha ejecutado el script $0, en el ordenador '$HOSTNAME'. " echo "Los atributos del script son: " echo $ATRIBUTOS_SCRIPT
Tambien podemos asignar la salida que producen los comandos del sistema a una variable. En nuestro ejemplo hemos asignado la salida del comando ‘ls -l a una variable llamada ATRIBUTOS_SCRIPT. Esto nos sera muy util en nuestros scripts para obtener informacion del sistema que podremos utilizar en nuestros scripts.
Usando caracteres especiales en variables
Existen una serie de caracteres que tienen un significado especial en Bash, por ejemplo $ y “. Si queremos usar literalmente estos caracteres en el valor de una variable tendremos que usar el simbolo ‘\’ delante de ellos.
#!/bin/bash MENSAJE="\"Hola Mundo ...\"" echo "El valor de la variable $MENSAJE es $MENSAJE"
Variables numericas
Si queremos definir variables numericas para su utilizacion en scripts Bash podemos utilizar el comando let. Nada mejor que un ejemplo para ver como se trabaja con variables numericas.
#!/bin/bash let A=100 let B=200 let C=$A+$B echo "A: $A | B: $B | C: $C"
Funciones
En Bash se pueden definir funciones. Una funcion en Bash (denominada subrutina o procedimiento en otros lenguajes de programacion) se podria definir como un script dentro de un script. Sirve para organizar un script en unidades logicas de manera que sea mas facil mantenerlo y programarlo. En Bash las funciones se pueden definir de la siguiente manera:
function nombre_de_funcion(){ comandos_del_shell }
Un ejemplo de funcion en un script:
#!/bin/bash let A=100 let B=200 # # Funcion suma() # Suma los variables A y B # function suma(){ let C=$A+$B echo "Suma: $C" } # # Funcion resta() # Resta los variables A y B # function resta(){ let C=$A-$B echo "Resta: $C" } suma resta
Bash (IV) – Estructuras de control y bucles
Por ralfm
Creado 01/10/2006 – 20:47
En nuestra cuarta entrega sobre la introduccion a el interprete de comandos Bash, vamos a ver una pequeña introduccion a las estructuras de control y bucles en Bash. Estas construcciones nos ayudan a controlar la ejecucion de un script y a obtener diversos resultados dependiendo de las condiciones que se cumplan o no cuando ejecutamos el script.
En Bash existen estas construcciones para controlar el flujo de ejecucion de un script:
- if/else: Ejecuta una serie de comandos dependiendo si una cierta condicion se cumple o no.
- for: Ejecuta una serie de comandos un numero determinado de veces.
- while: Ejecuta una seria de comandos mientras que una determinada condicion sea cumpla.
- until: Ejecuta una serie de comandos hasta que una determinada condicion se cumpla.
- case: Ejecuta una o varias listas de comandos dependiendo del valor de una variable.
- select: Permite seleccionar al usuario una opcion de una lista de opciones en un menu.
La mayoria de condiciones utilizadas con estas construcciones son comparaciones de cadenas alfanumericas o numericas, valores de terminacion de comandos y comprobaciones de atributos de ficheros. Antes de seguir viendo como estas construcciones se pueden utilizar, vamos a ver como las condiciones se pueden definir.
Comparaciones de cadenas alfanumericas
Operador Verdad (TRUE) si: ------------------------------------------ cadena1 = cadena2 cadena1 es igual a cadena2 cadena1 != cadena2 cadena1 no es igual a cadena2 cadena1 < cadena2 cadena1 es menor que cadena2 cadena1 > cadena 2 cadena1 es mayor que cadena 2 -n cadena1 cadena1 no es igual al valor nulo (longitud mayorque 0) -z cadena1 cadena1 tiene un valor nulo (longitud 0)
Comparacion de valores numericos
Operador Verdad (TRUE) si: ------------------------------------------ x -lt y x menor que y x -le y x menor o igual que y x -eq y x igual que y x -ge y x mayor o igual que y x -gt y x mayor que y x -ne y x no igual que y
Comprobacion de atributos de fichero
Operador Verdad (TRUE) si: ------------------------------------------ -d fichero fichero existe y es un directorio -e fichero fichero existe -f fichero fichero existe y es un fichero regular (no un directorio, u otro tipo de fichero especial) -r fichero Tienes permiso de lectura en fichero -s fichero fichero existe y no esta vacio -w fichero Tienes permiso de escritura en fichero -x fichero Tienes permiso de ejecucion en fichero (o de busqueda si es un directorio) -O fichero Eres el dueño del fichero -G fichero El grupo del fichero es igual al tuyo. fichero1 -nt fichero2 fichero1 es mas reciente que fichero2 fichero1 -ot fichero2 fichero1 es mas antiguo que fichero2
Podemos combinar varias condiciones con los simbolos ‘&&’ (AND) y ‘||’ (OR), y negar una condicion con ‘!’. Unos ejemplos mas adelante aclararan como utilizarlos.
if/else
La sintaxis de esta construccion es la siguiente:
if "condicion" then "comandos" [elif "condicion" then "comandos"] [else "comandos"] fi
Como ya hemos dicho, podemos comprobar los valores de terminacion de un comando, y comparar cadenas alfanumericas/numericas y atributos de ficheros. Nada mejor que unos ejemplos para aclararnos las ideas.
#!/bin/bash # # Comprobando terminacion de un comando # DIRECTORIO="/tmp/test" COMANDO="/bin/mkdir $DIRECTORIO" if $COMANDO then echo "$DIRECTORIO ha sido creado" else echo "$DIRECTORIO no pudo ser creado" fi
#!/bin/bash # # Comparacion de cadenas alfanumericas # CADENA1="uno" CADENA2="dos" CADENA3="" if [ $CADENA1 = $CADENA2 ]; then echo "$CADENA1 es igual a $CADENA2" elif [ $CADENA1 != $CADENA2 ]; then echo "$CADENA1 no es igual a $CADENA2" fi if [ -z $CADENA3 ]; then echo "$CADENA3 esta vacia" fi
#!/bin/bash # # Comparacion de valores numericos # let NUM1=1 let NUM2=2 let NUM3=3 if [ $NUM1 -ne $NUM2 ] && [ $NUM1 -ne $NUM3 ]; then echo "$NUM1 es diferente a $NUM2 y $NUM3" fi if [ $NUM1 -lt $NUM3 ]; then echo "$NUM1 es menor que $NUM3" fi
for
La sintaxis de esta construccion es la siguiente:
for nombre [in lista] do comandos que pueden utilizar $nombre done
Un ejemplo nos aclarara las cosas. Vamos a listar informacion en el DNS de una lista de direcciones web:
#!/bin/bash for HOST in www.google.com www.altavista.com www.yahoo.com do echo "-----------------------" echo $HOST echo "-----------------------" /usr/bin/host $HOST echo "-----------------------" done
while
La sintaxis de esta construccion es la siguiente:
while condicion do comandos done
Un ejemplo simple con while en donde escribimos el valor de una variable 10 veces, despues de incrementar su valor:
#!/bin/bash NUM=0 while [ $NUM -le 10 ]; do echo "$NUM: $NUM" let NUM=$NUM+1 done
until
La sintaxis de esta construccion es la siguiente:
until condicion; do comandos done
Un ejemplo simple con until en donde escribimos el valor de una variable 10 veces, despues de incrementar su valor:
#!/bin/bash NUM=0 until [ $NUM -gt 10 ]; do echo "$NUM: $NUM" let NUM=$NUM+1 done
case
La sintaxis de esta construccion es la siguiente:
case expresion in caso_1 ) comandos;; caso_2 ) comandos;; ...... esac
Un ejemplo simple con case para aclarar las cosas:
#!/bin/bash for NUM in 0 1 2 3 do case $NUM in 0) echo "$NUM es igual a cero";; 1) echo "$NUM es igual a uno";; 2) echo "$NUM es igual a dos";; 3) echo "$NUM es igual a tres";; esac done
select
La sintaxis de esta construccion es la siguiente:
select nombre [in lista] do comandos que pueden utilizar $nombre done
Un ejemplo simple para aclarar las cosas.
#!/bin/bash select OPCION in opcion_1 opcion_2 opcion_3 do if [ $OPCION ]; then echo "Opcion elegida: $OPCION" break else echo "Opcion no valida" fi done
1 comment Enero 18, 2007
Tipo de almacenamiento MERGE.
Sacado del manual de mysql encontramos un tipo de tabla denominada MERGE o MRG_MyISAM que permite juntar el contenido de varias tablas en una sola de modo automático.
Según el manual de mysql:
El motor de almacenamiento MERGE , también conocido como MRG_MyISAM , es una colección de tablas MyISAM idénticas que pueden usarse como una. “Idéntica”significa que todas lsas tablas tienen información de columna e índice idéntica. No puede mezclar tablas en que las columnas se listen en orden distinto, no tengan exactamente las mismas columnas, o tengan los índices en orden distinto. Sin embargo, alguna o todas las tablas pueden comprimirse con myisampack. Consulte Sección 8.2, “myisampack, el generador de tablas comprimidas de sólo lectura de MySQL”. Diferencias en las opciones de las tablas tales como AVG_ROW_LENGTH, MAX_ROWS, o PACK_KEYS no importan.
Cuando crea una tabla MERGE , MySQL crea dos ficheros en disco. Los ficheros tienen nombres que comienzan con el nombre de la tabla y tienen una extensión para indicar el tipo de fichero, Un fichero .frm almacena la definición de tabla , y un fichero .MRG contiene los nombres de las tablas que deben usarse como una. Las tablas no tienen que estar en la misma base de datos que la tabla MERGE misma.
Puede usar SELECT, DELETE, UPDATE, y INSERT en la colección de tablas, Debe tener permisos de SELECT, UPDATE, y DELETE en las tablas que mapea a una tabla MERGE.
Si hace un DROP de la tabla MERGE , sólo borra la especificación MERGE . Las tablas subyacentes no se ven afectadas.
Cuando crea una tabla MERGE , debe especificar una cláusula UNION=(list-of-tables) que indica qué tablas quiere usar como una. Puede especificar opcionalmente una opción INSERT_METHOD si quiere que las inserciones en la tabla MERGE se realicen en la primera o última tabla de la lista UNION . Use un valor de FIRST o LAST para hacer que las inserciones se hagan en la primera o última tabla, respectivamente. Si no especifica una opción INSERT_METHOD o si la especifica con un valor de NO, intentos de insertar registros en la tabla MERGE producen un error.
El siguiente ejemplo muestra cómo crear una tabla MERGE :
mysql> CREATE TABLE t1 (
-> a INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
-> message CHAR(20));
mysql> CREATE TABLE t2 (
-> a INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
-> message CHAR(20));
mysql> INSERT INTO t1 (message) VALUES ('Testing'),('table'),('t1');
mysql> INSERT INTO t2 (message) VALUES ('Testing'),('table'),('t2');
mysql> CREATE TABLE total (
-> a INT NOT NULL AUTO_INCREMENT,
-> message CHAR(20), INDEX(a))
-> TYPE=MERGE UNION=(t1,t2) INSERT_METHOD=LAST;
Tenga en cuenta que la columna a está indexada en la tabla MERGE , pero no está declarada como PRIMARY KEY como lo está en las tablas MyISAM subyacente. Esto es necesario ya que una tabla MERGE no puede forzar unicidad en un conjunto de tablas subyacentes.
Tras crear la tabla MERGE, puede realizar consultas que operen en el grupo de tablas como unidad:
mysql> SELECT * FROM total;
+---+---------+
| a | message |
+---+---------+
| 1 | Testing |
| 2 | table |
| 3 | t1 |
| 1 | Testing |
| 2 | table |
| 3 | t2 |
+---+---------+
Tenga en cuenta que puede manipular el fichero .MRG directamente desde fuera del servidor MySQL :
shell> cd /mysql-data-directory/current-database
shell> ls -1 t1 t2 > total.MRG
shell> mysqladmin flush-tables
Para rempaear una tabla MERGE a una colección diferente de tablas MyISAM, puede realizar una de las siguientes opciones:
DROP la tabla MERGE y recrearla.
Use ALTER TABLE tbl_name UNION=(…) para cambiar la lista de tablas subyacentes.
Cambie el fichero .MRG y realice un comando FLUSH TABLE para la tabla MERGE y todas las tablas subyacentes para forzar al motor de almacenamiento a leer el nuevo fichero de definición.
Las tablas MERGE pueden ayudarle a arreglar los siguientes problemas:
Administrar fácilmente un largo conjunto de tablas. Por ejemplo, puede poner datos de meses distintos en tablas separadas, comprimir algunos de ellos con myisampack, y luego crear una tabla MERGE para usarlas como una.
Obtener más velocidad. Puede dividir una tabla grande de sólo lectura basándose en algún criterio, y luego poner las tablas individuales en distintos discos. Una tabla MERGE puede ser mucho más rápida que usar una tabla grande.
Realizar búsquedas más eficientes. Si conoce exactamente lo que busca, puede buscar en sólo una de las tablas divididas y usar una tabla MERGE para las otras. Puede tener distintas tablas MERGE que usen conjuntos no disjuntos de tablas.
Realizar reparaciones más eficientes. Es más fácil de reparar tablas individuales mapeadas en una tabla MERGE que reparar una única tabla grande.
Mapear instantáneamente varias tablas como una. Una tabla MERGE no necesita mantener un índice propio ya que usa los índices de las tablas individuales. Como resultado, las colecciones de tablas MERGE son muy rápidas de crear o remapear. (Tenga en cuenta que debe especificar las definiciones de índices cuando crea una tabla MERGE , incluso cuando no se crean índices.)
Si tiene un conjunto de tablas que une como una tabla grande bajo demanda o batch, debe crear una tabla MERGE sobre ellas bajo demanda. Esto es mucho más rápido y ahorra mucho espacio de disco.
Excede el límite de tamaño del sistema operativo. Cada tabla MyISAM está ligada a este límite, pero una colección de tablas MyISAM no lo está.
Puede crear un alias o sinónimo para una tabla MyISAM definiendo una tabla MERGE que mapee a una tabla. No debería haber un impacto de rendimiento realmente impactante al hacer esto (sólo un par de llamadas indirectas y llamadas memcpy() para cada lectura).
Las desventajas de las tablas MERGE son:
Sólo puede usar tablas MyISAM idénticas para una tabla MERGE .
No puede usar un número de características MyISAM en tablas MERGE . Por ejemplo, no puede crear índices FULLTEXT en tablas MERGE . (Puede crear índices FULLTEXT en las tablas MyISAM subyacentes, puero no puede buscar en la tabla MERGE con búsquedas full-text.)
Si la tabla MERGE no es temporal, todas las tablas subyacentes MyISAM deben ser permanentes. Si la tabla MERGE es temporal, las tablas MyISAM pueden ser cualquier mezcla de tablas temporales y no temporales.
Las tablas MERGE usan más descriptores de fichero. Si 10 clientes usan una tabla MERGE que mapee a 10 tablas, el servidor usa (10*10) + 10 descriptores de fichero. (10 descriptores de ficheros de datos para cada uno de los 10 clientes, y 10 descriptores de ficheros de índice compartidos entre los clients.)
Las lecturas de claves son más lentas. Cuando lee una clave, el motor de almacenamiento MERGE necesita leer en todas las tablas subyacentes para chequear cuál se parece más a la clave dada. Si luego lee el siguiente, el motor MERGE necesita buscar en los buffers de lectura para buscar la siguiente clave. Sólo cuando se usa un búffer de claves el motor necesita leer el siguiente bloque de claves. Esto hace que las claves MERGE sean mucho más lentas en búsquedas eq_ref , pero no mucho más lentas en búsquedas ref . Consulte Sección 7.2.1, “Sintaxis de EXPLAIN (Obtener información acerca de un SELECT)” para más información sobre eq_ref y ref.
Add comment Enero 18, 2007
Obtención de las fechas de un fichero con el comando stat
El uso de stat nos permite obtener diferentes datos de un fichero. Tamaño, fechas de acceso, última
Ejemplos:
stat fichero.txt s
Size: 761 Blocks: 8 IO Block: 4096 Regular File
Device: 802h/2050d
Inode:98628
Links: 1 Access: (0700/-rwx——) Uid: ( 0/ root) Gid: (0/
root)
Access: Thu Jan 18 11:01:31 2007
Modify: Thu Jan 18 11:01:22 2007
Change: Thu Jan 18 11:01:22 2007
stat -c %y fichero.txt | awk ‘{printf $1 “\n”}’
3 comments Enero 18, 2007
