El Shell Bash

El Shell Bash

El Shell Bash

Ficheros de configuración y variables de entorno

Programación básica del Shell Control de flujo Opciones de la línea de comandos,

expresiones aritméticas y arrays.

Ficheros de configuración (…)

/etc/profile se ejecuta siempre para todos los usuarios al logarnos en el sistema.

Posteriormente se comprueba si en el home del usuario existe el archivo .bash_profile (puede llamarse también .profile o .bash_login), en el se puede establecer configuración de entorno personalizada.

Si queremos aplicar cambios en .bash_profile sin tener que volvernos a logar, usariamos el comando source.

Si lo que queremos es ejecutar opciones de entorno para cada Shell que ejecutemos (abrir un Xterm), podemos usar el archivo .bashrc. Este archivo permite definir configuraciones adicionales.

Por último .bash_logout define ordenes que se ejecutarán al abandonar la cuenta de usuario, borrar ficheros temporales o almacenar datos de usuarios.

Ejemplo comando source:$ source .bash_profile


Variables de entorno:– Permiten configurar el entorno en el que se ejecutan los

programas.– IMP. No deben contener espacios entre nombre y valor– Para obtener el valor de la variable debemos usar el

operador ‘$’.– Para eliminar una variable usaremos el comand unset.Ejemplos:

$ NOMBRE=‘Guillermo Hernández’$ echo $NOMBREGuillermo Hernández$ unset NOMBRE


Podemos configurar nuestro prompt configurando las variables de entorno PS1 y PS2. Los valores que podemos asignarles aparecen en la tabla 3.2, página 43.

– Ejemplo que mostraría # como prompt para root y $ para el resto, opción \$:

~-> PS1=‘\w\$’

~$


Hay una serie de variables de entorno predefinidas en el sistema, ver tabla 3.3 de la página 44.

Las variables de entorno tal y como las hemos definido solo podrían ser usadas por nuestro Bash y los comando interactivos que ejecutemos, nunca por los subprocesos que Bash arranque. Para ello debemos exportarlas:

$ EDITOR=/sw/bin/joe$ export EDITOR

Para visualizar las variables de entorno exportadas usaremos el comando export o env. Para obtener las variables no exportadas usaremos set.

El Shell Bash




Programación básica del Shell

Un script es un fichero que contiene comados Bash ejecutables. Por ejemplo .bash_profile o .bashrc.

Para ejecutar un script lo haremos usando el comando source, (local al Shell y por tanto verá todas las variables de entorno del Shell). Ó asignandole permiso de ejecución lo cual implicará que se ejecutará en un subShell que ya no verá las variables de entorno del Shell padre, sólo las que se hayan exportado.


Funciones:– Son extensiones a los scripts, son heredadas del Bourne

Shell.– Se ejecutan dentro de la memoria del propio Shell, por lo

que son más eficientes que ejecutar otro script.Bourne Shell C Shell

function nombrefn nombrefn(){ {

…. ….} }

– Para eliminar una función se ejecutará unset –f nombrefn.– Para ejecutar una función se escribirá su nombre seguida

por los argumentos que requiera, al igual que un comando.– Ver orden de preferencia de símbolos página 47.


Variables del Shell:– Por defecto todas las variables son de tipo cadena.– Por convenio las variables que queramos exportar se escribirán en

mayúsculas, las que no en minúsculas.– Los parámetros posicionales son los encargados de recibir los

argumentos de un script y parámetros de una función: $1,$2,$3 … el parámetro $0 recibe el nombre del script que se ejecuta:

Ejemplo: ejemplo.sh#!/bin/bash# Ejemplo de script que recibe parámetrosecho “El script se llama $0”echo “Recibe los parámetros $1, $2, $3 y $4”

$ chmod g+x,o+x ejemplo.sh$ ejemplo hola adiosEl script ./ejemplo.shRecibe los parámetros hola adios


Variables locales y globales:– Los parámetros posicionales son siempre locales al script o

función, mientras que el resto de variables del script serán siempre globales.

#!/bin/bash

# Script que llama a una función para saludar de nombre saluda.sh

function diHola

{

echo “Hola $1”

}

$ saluda.sh Guille

Hola


– Si quisieramos que la función recibiera el parámetro de entrada al script haríamos:

#!/bin/bash

# Script que llama a una función para saludar de nombre saluda.sh

function diHola

{

echo “Hola $1”

}

diHola $1

– Al ejecutarlo tendríamos lo que buscamos:$ saluda.sh Guille

Hola Guille


– El resto de variables de un script serán siempre globales a éste:

#!/bin/bash# Ejemplo de variables globales dondeestoyfunction EstasAqui{

donde=‘Dentro de la función’}donde=‘En el script’echo $dondeEstasAquiecho $donde

– Al ejecutar el script tendríamos la siguiente respuesta:$ dondeestoyEn el scriptDentro de la función


– Si queremos que una variable no posicional sea local, utilizaremos el modificador local:

#!/bin/bash# Ejemplo de variables globales dondeestoyfunction EstasAqui{

local donde=‘Dentro de la función’}donde=‘En el script’echo $dondeEstasAquiecho $donde

– Al ejecutar el script con este cambio tendríamos la siguiente respuesta:

$ dondeestoyEn el scriptEn el script


– Comentar también por último que las variables globales también se pueden definir dentro de una función.

– Existen variables con un significado especial. Estas son: $#, $@ y $*

– $# nos devuelve el número de parámetros que recibe una función en formato cadena.

– $* y $@ nos devuelven todos los argumentos recibidos por un script o función.


Ejemplo: recibe.sh#Ejemplo de script que recibe parámetros y los muestraecho “El script $0 recibe $# argumentos que son:” $*echo “El script $0 recibe $# argumentos que son:” $@

– Al ejecutarlo obtendríamos:$ recibe hola adiosEl script ./recibe.sh recibe 2 argumentos que son: hola adiosEl script ./recibe.sh recibe 2 argumentos que son: hola adios

– Al entrecomillar (comillas simples), los parámetros $@ y $* es cuando aparecen sus diferencias. La primera, es que $* nos permite separar los argumentos con el carácter especificado en la variable IFS (Internal Field Separator), mientras que $@ siempre usa un espacio en blanco.


Ejemplo: recibe.sh

#Ejemplo de script que recibe parámetros y los muestra

IFS=‘,’

echo “El script $0 recibe $# argumentos que son:” $*

echo “El script $0 recibe $# argumentos que son:” $@

– Al ejecutarlo obtendríamos:$ recibe hola adios

El script ./recibe.sh recibe 2 argumentos que son: hola,adios

El script ./recibe.sh recibe 2 argumentos que son: hola adios


– Hay otra diferencia entre $* y $@, y se produce cuando usamos parámetros entrecomillados. (ver página 54)

– Las reglas generales que debemos seguir al usar estas variables son las siguientes:

Siempre conviene entrecomillar las variables $* y $@ para evitar que los argumentos que contengan espacios sean malinterpretados.

Si queremos cambiar el delimitador que separa los argumentos deberemos usar $* y la variable IFS.

Si lo que queremos es pasar los argumentos a una función debemos usar $2 entrecomillado.


Expansión de variables:– $VAR es una simplificación de la sintaxis general ${VAR}, que es

la manera en la que debemos expandir una variable.

Ejemplo:

$ nombre=Fernando

$ apellido=Lopez

$ echo “$nombre_$apellido”

Lopez

El sistema buscaría la variable nombre_, que no existe. En cambio, si ejecutamos:

$ echo “${nombre}_$apellido”

Fernando_Lopez


Operadores cadena:– Los operadores cadena permiten manipular cadenas sin necesidad de

escribir complicadas rutinas de procesamiento. Los operadores cadena más importantes pueden verse en la tabla 4.1, página 57.

Ejemplos:

Imaginemos que tenemos un fichero con los nombres y los sueldos de un conjunto de clientes:

$ cat clientes

45340 Jose Carlos Martinez

24520 Mari Carmen Gutierrez

450 Luis Garcia Santos

….

Escribir un script que imprima los N clientes que más saldo tienen. El script recibirá como primer argumento el nombre del fichero, y como segundo opcionalmente el número de clientes a imprimir (por defecto 5).


Solución:

# Script que saca los mejores clientes

# Tiene la forma:

# mejoresclientes <fichero> [<cuantos>]

fichero=$1

cuantos=$2

defecto=5

sort –nr $fichero | head -${cuantos:-$defecto}


Operadores de búsqueda de patrones:– Se utilizan para eliminar partes de la ruta de un fichero, como pueda

ser el directorio o el nombre del fichero.– En la tabla 4.2 de la página 60.

Ejemplos:

$ruta=/usr/local/share/qemu/bios.core.bin

Operadors Resultado

${ruta##/*/} bios.core.bin

${ruta#/*/} local/share/qemu/bios.core.bin

ruta /usr/local/share/qemu/bios.core.bin

${ruta%.*} /usr/local/share/qemu/bios.core

${ruta%%.*} /usr/local/share/qemu/bios


Sustitución de comandos:– Nos permite usar la salida de un comando como si fuera el valor de una

variable. La sintaxis es:$(comando)

Ejemplo:$midir=$(ls $HOME)$echo $midirDesktop Documents Library Movies Music Pictures Public Sites autor jdevhome tmp xcode

– También podemos cargar el contenido de un fichero en una variable de entorno con la sintaxis $(<fichero)..

$copyrigth=$(<copyrigth.txt)– Otro comando interesante es el operador longitud.

$nombre=“Guillermo”${#nombre}$9

El Shell Bash




Control de flujo

Sentencias if,elif y else:

if condicion if condicion ; thenthen sentencias sentencias elif condicion ; thenelif condicion sentenciasthen else sentencias sentenciaselse fi sentenciasfi

– Este lenguaje nos obliga a que las sentencias estén organizadas con retornos de carro. Si queremos hacerlo en la misma línea debemos utilizar el separador de comandos en Bash (;).

Control de flujo

En UNIX los comando terminan devolviendo un código numérico al que se llama código de terminación, que indica si el comando tuvo éxito o no.

Un código de terminación 0 indica que el comando tuvo éxito y un código entre 1 y 255 significa que se produjo un error con un significado determinado.

El significado de los códigos dependerá del comando. Por ejemplo el comando diff devuelve 0 si no hay diferencas entre dos ficheros, 1 cuando hay diferencias y 2 cuando se produce algún error (por ejemplo que no se pueda leer alguno de ellos).

La sentencia if comprueba el código de terminación de un comando en la condicion, si éste es 0 la condición se evalua como cierta.

if comando ; thenprocesamiento normal

elseprocesamiento con errores

fi

Control de flujo

Operadores lógicos– Son && (and lógico), || (or lógico) y ! (not lógico).– Estos operadores pueden combinarse en una sentencia if para

realizar condiciones más complejas.

if cd /tmp && cp 001.tmp $HOME ; then….

fi

– Si el primer comando no tiene éxito no se ejecutaría el siguiente.– El comando test nos permite evaluar si un comando es correcto

sin ejecutarlo. Un sinónimo de test son los corchetes [ ].

[ cadena1 = cadena2 ]Los espacios son obligatorios.

Control de flujo

Operadores de comparación de cadenas. Tabla 5.1 en la página 74.– Pueden usarse con el comando test

Operadores para la númerica de enteros. Tabla 5.2 en la página 76.

Ejemplos:if [ $reintegro -le $saldo -a \ $reintegro -le $max_cajero ]then …..fi

Operadores para la comprobación de atributos de ficheros. Tabla 5.3 en la página 77.

Control de flujo

El bucle for:– La sintaxis es la siguiente:

for var [in lista]do

.....sentencias que usan $var.....

done

– La semántica es distinta a los bucles for de otros lenguajes. Este se parece más a un for each in lista. Se repite tantas veces como elementos haya en la lista entre corchetes.

– Si se omite la lista, por defecto se recorre el contenido de la variable de entorno $@.

Control de flujo

Ejemplos:

for planeta in Mercury Venus Terra Marte Jupiter Saturnodo

echo $planeta # imprimimos cada planetadone

– La lista puede contener comodines. El siguiente ejemplo recorrería todos los ficheros del directorio actual:

for fichero in *do

ls –l “$fichero”done

Control de flujo

– Para recorrer todos los parámetros que recibe un script, usaremos “$@”. Es importante entrecomillar la variable $@ ya que si no, no se interpretan bien los parámetros con espacios.#!/bin/bash# bucle que recorre todos los argumentos recibidosfor arg in “$@”do

echo “Elemento:$arg”done

– La ejecución sería:$ recibe “el perro” “la casa”Elemento:El perroElemento:La casa

Control de flujo

Bucles while y until.– Su sintaxis es la siguiente:

while comando until comandodo do

.... ......done done

– El comando también puede ser una opción encerrada entre []. La diferencia entre while y until, es que while se ejecuta mientras el resultado del comando sea exitoso, es decir 0. Mientras que until se ejecuta hasta que el código de terminación sea exitoso. Por tanto until se puede interpretar como un bucle que ejecuta un comando hasta que tenga éxito.

Control de flujo

Ejemplo:

#!/bin/bash# Script que muestra los directorios del PATHpath=$PATHwhile [ $path ] ; do

echo ${path%%:*}if [ ${path#*:} = $path ] ; then

path=else

path=${path#*:}fi

done

Control de flujo

La sentencia case:– Mientras que en otros lenguajes de programación esta sentencia

permite comprobar el valor de una variable simple, como un entero o un carácter, en Bash permite realizar una comparación de patrones con la cadena a examinar:

case cadena inpatron1) sentencias ;;patron2) sentencias ;;.....

esac– Los patrones pueden ser varios separados por |. Si cadena

cumple alguno de los patrones, se ejecutan sus correspondientes sentencias (que se separan por ;) hasta ;;.

Control de flujo

Ejemplo:

#!/bin/bash# Script que convierte ficheros de imagen a formato .jpg

for fichero in “$@”do

fichero_ppm=${fichero%.*}.ppmcase $fichero in

*.jpg) exit 0;;*.tga) tgatoppm $fichero > $fichero_ppm;;*.xpm) xpmtoppm $fichero > $fichero_ppm;;

esacfichero_salida=${fichero_ppm%.ppm}.jpgpnmtojpeg $fichero_ppm > $fichero_salida

Control de flujo

Sentencia select:– La sentencia select nos permite generar fácilmente un menú simple. Su sintaxis es la

siguiente:

select variable [in lista]do

sentencias que usan $variabledone

– Al igual que el bucle for, si omitimos [in lista], se recorre $@.– La sentencia genera un menú con los elementos de lista, donde asigna un número a

cada elemento, y pide al usuario que introduzca un número. El valor elegido lo almacena en variable, y el número elegido en la variable REPLY. Una vez elegida una opción por parte del usuario, se ejecuta el cuerpo de la sentencia y el proceso se repite en un bucle infinito.

– Aunque es un bucle infinito, podemos forzar su salida con la sentencia break. Por otro lado, el prompt que utiliza para el menú, puede definirse en la variable PS3. Por defecto vale #?.

El Shell Bash




Opciones de la línea de comandos

La sentencia shift:– Los comandos UNIX suelen tener el formato siguiente:

comando [opciones] argumentos

– Es decir las opciones suelen preceder a los argumentos y suelen tener un guión delante.

– Las opciones al igual que los argumentos residen en las variables posicionales. Por ejemplo si ejecutamos hacer –o esto.txt aquello.txt, en $1 tendríamos –o, en $2 tendríamos esto.txt y en $3 tendríamos aquello.txt. Por tanto para tratar las opciones no tendríamos problemas, excepto por el motivo de que son opcionales.


if [ $1 = -o ] ; thenEjecuta la operación con $2 y $3

elseEjecuta la operación con $1 y $2

fi

– En consecuencia el número de opciones crece y la programación se vuelve bastante engorrosa.

– La sentencia shift nos permite solucionar esto de una forma elegante. La sintaxis de esta sentencia es:

shift [n]


[n] opcional, es el número de desplazamientos a la izquierda que queremos hacer con los argumentos, si se omite n=1. Podemos reescribir el ejemplo anterior utilizando shift.

if [ $1 = -o ] ; thenProcesa –oshift

fiEjecuta las operaciones con $1 y $2


El siguiente ejemplo hacer recibe tres posibles opciones –a, -b y –c. La forma de implementar el reconocimiento de estas opciones sería:

while [ -n “$(echo $1 | grep ‘^-’)” ]do

case $1 in-a) Procesa opción –a;;-b) Procesa opción –b;;-c) Procesa opción –c;;* ) echo ‘Use hacer [-a] [-b] [-c] args ...’

esacs shift

done