El Shell Bash

1. El Shell Bash

2. 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.

3. 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

4. Ficheros de configuración (…) • 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 $NOMBRE Guillermo Hernández $ unset NOMBRE

5. Ficheros de configuración (…) • 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\$’ ~$

6. Ficheros de configuración (…) • 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.

7. 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.

8. 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.

9. Programación básica del Shell • 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 ShellC 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.

10. Programación básica del Shell • 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ámetros echo “El script se llama $0” echo “Recibe los parámetros $1, $2, $3 y $4” $ chmod g+x,o+x ejemplo.sh $ ejemplo hola adios El script ./ejemplo.sh Recibe los parámetros hola adios

11. Programación básica del Shell • 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

12. Programación básica del Shell • 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

13. Programación básica del Shell • El resto de variables de un script serán siempre globales a éste: #!/bin/bash # Ejemplo de variables globales dondeestoy function EstasAqui { donde=‘Dentro de la función’ } donde=‘En el script’ echo $donde EstasAqui echo $donde • Al ejecutar el script tendríamos la siguiente respuesta: $ dondeestoy En el script Dentro de la función

14. Programación básica del Shell • Si queremos que una variable no posicional sea local, utilizaremos el modificador local: #!/bin/bash # Ejemplo de variables globales dondeestoy function EstasAqui { local donde=‘Dentro de la función’ } donde=‘En el script’ echo $donde EstasAqui echo $donde • Al ejecutar el script con este cambio tendríamos la siguiente respuesta: $ dondeestoy En el script En el script

15. Programación básica del Shell • 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.

16. Programación básica del Shell Ejemplo: recibe.sh #Ejemplo de script que recibe parámetros y los muestra 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 • 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.

17. Programación básica del Shell 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

18. Programación básica del Shell • 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.

19. Programación básica del Shell • 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

20. Programación básica del Shell • 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).

21. Programación básica del Shell 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}

22. Programación básica del Shell • 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 OperadorsResultado ${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

23. Programación básica del Shell • 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 $midir Desktop 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

24. 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.

25. Control de flujo • Sentencias if,elif y else: if condicion if condicion ; then then sentencias sentencias elif condicion ; then elif condicion sentencias then else sentencias sentencias else fi sentencias fi • 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 (;).

26. 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 ; then procesamiento normal else procesamiento con errores fi

27. 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.

28. 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.

29. 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 eachin 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 $@.

30. Control de flujo • Ejemplos: for planeta in Mercury Venus Terra Marte Jupiter Saturno do echo $planeta # imprimimos cada planeta done • La lista puede contener comodines. El siguiente ejemplo recorrería todos los ficheros del directorio actual: for fichero in * do ls –l “$fichero” done

31. 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 recibidos for arg in “$@” do echo “Elemento:$arg” done • La ejecución sería: $ recibe “el perro” “la casa” Elemento:El perro Elemento:La casa

32. Control de flujo • Bucles while y until. • Su sintaxis es la siguiente: while comando until comando do 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.

33. Control de flujo • Ejemplo: #!/bin/bash # Script que muestra los directorios del PATH path=$PATH while [ $path ] ; do echo ${path%%:*} if [ ${path#*:} = $path ] ; then path= else path=${path#*:} fi done

34. 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 in patron1) 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 ;;.

35. Control de flujo • Ejemplo: #!/bin/bash # Script que convierte ficheros de imagen a formato .jpg for fichero in “$@” do fichero_ppm=${fichero%.*}.ppm case $fichero in *.jpg) exit 0;; *.tga) tgatoppm $fichero > $fichero_ppm;; *.xpm) xpmtoppm $fichero > $fichero_ppm;; esac fichero_salida=${fichero_ppm%.ppm}.jpg pnmtojpeg $fichero_ppm > $fichero_salida

36. 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 $variable done • 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 #?.

37. 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.

38. 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.

39. Opciones de la línea de comandos if [ $1 = -o ] ; then Ejecuta la operación con $2 y $3 else Ejecuta 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]

40. Opciones de la línea de comandos • [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 ] ; then Procesa –o shift fi Ejecuta las operaciones con $1 y $2

41. Opciones de la línea de comandos • 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