PROGRAMACIÓN DE SHELL SCRIPTS

INTRODUCCIÓN La idea es combinar secuencias de comandos de Linux para realizar determinadas tareas. Con shell scripts podremos definir variables y asignarle valores o permitir que un usuario inserte valores de forma interactiva. Dispondremos de bucles y estructuras de control para realizar operaciones aritméticas o de comparación. También podremos tener varios shells scripts ejecutándose al mismo tiempo.

Variables de entorno Una variable de entorno es un objeto designado para contener información usada por una o más aplicaciones. Usando variables de entorno podemos cambiar una opción de configuración para una o más aplicaciones fácilmente.

Variables de entorno VARIABLE DESCRIPCIÓN PATH Esta variable contiene una lista de directorios separados por “:” en la cual el sistema buscará los archivos ejecutables. LOGNAME Esta variable contiene nuestro nombre de usuario. HOME Camino absoluto al directorio LOGIN del usuario. PS1 Es el carácter de prompt inicial “$”. PS2 Continuación del prompt, “>” SHELL Contiene el nombre de la shell que estamos usando

Variables de usuario Para referirse al valor de una variable debemos anteponer a su nombre el signo de $, ej: $nom, así la shell sustituye $nom por el valor que tenga asignado esa variable. Por ejemplo podemos saber qué shell estamos usando y qué usuario somos escribiendo la línea: $ echo Mi nombre de usuario es $LOGNAME y utilizo como shell predeterminada $SHELL.

Variables de usuario Una variable es un identificador, y en Linux por defecto son de tipo carácter. Para asignar un valor, se escribe el nombre seguido de un símbolo de =, seguido del valor. No deben existir espacios en blanco entre el signo de igual y el nombre de la variable ó el valor. El nombre de una variable no puede empezar por un número. Las variables de shell existen mientras la shell esté activa. Al salir de la sesión se terminará la shell de inicio de sesión y al volver a iniciar la sesión tendremos que definir nuevamente cualquier variable que hayamos definido anteriormente.

Ejemplos Defina las siguientes variables: a=hola b=2000 texto=“ la hora actual es: “ Para visualizar el valor de las variables: echo $a echo $texto $b

Ejercicios Ejercicio: Defina una variable llamada “nom”, con su nombre y otra “ape” con su apellido, a continuación muestre por pantalla el mensaje “Mi nombre completo es Fulano de Tal”, utilizando las variables que acaba de declarar. Crear un directorio llamado “tablas”, dentro un archivo llamado “t1”, con 5 registros (Nombre, Apellido, Edad, Dirección). Vuelva a su directorio personal y declare una variable con la ruta a “t1” corte la segunda y la última columna del “t1” utilizando la variable que acaba de declarar, en lugar de la ruta.

Variables Para obtener una lista de todas las variables podemos utilizar el comando “set”. Para eliminar una variable podemos usar el comando “unset”, seguido del nombre de la variable.

Valores de variables Pueden ser cadenas de caracteres. El resultado de ejecutar un comando. Puede incluir caracteres especiales como el *, en el nombre de una variable usando comillas dobles o simples, o backslash para anular significados especiales. Si lo que queremos es utilizar el metacaracter asterisco o ejecutar un comando entonces debemos usar comillas ivnertidas. Sin embargo las comillas dobles no convierten en texto el signo de pesos. Todavía se evalúa un nombre de variable encerrado en comillas dobles, remplazándolo con el valor de la variable. El valor de la variable después se volverá parte de la cadena de comandos.

Valores de variables Las comillas sencillas suprimen cualquier evaluación de variable y tratan al signo de pesos como otro carácter. Ejemplo: ganador=daniel resultado=‘El nombre está en $ganador’ echo $resultado El nombre está en $ganador. Además podemos usar la diagonal invertida para convertir en texto cualquier metacaracter. Ej: resultado=“$ganador ganó \$10000”

Valores de variables Podemos asignar el resultado de un comando a una variable (como una forma de definir un alias), utilizando comillas sencillas. Para ejecutarlo usamos $ pero no echo. Ej: $ lsal=‘ls – l’ Con $lsal ejecutamos el comando.

Comillas invertidas Para asignar el resultado de los comandos a una variable, primero necesitamos ejecutar el comando. Al colocar un comando entre comillas invertidas se ejecutará primero este comando y su resultado es lo que se asigna a la variable. Aquí podemos utilizar metacaracters y filtros con expresiones regulares. Es necesario usar echo.

Nuestros primeros programas Para crear un shell script primero creamos un archivo de texto con un editor (vi, emacs o gedit, por ejemplo). Este archivo contendrá las órdenes que la shell va a ir interpretando y ejecutando. Luego de creado el archivo es necesario darle permiso de ejecución, con chmod. Hecho eso podemos ejecutarlo como cualquier orden.

Primer programa Elegir un nombre para el programa. Editarlo con vi. Ej. vi prog1 Generaremos el siguiente archivo: ######### # Prueba # who date 4) Guardamos los cambios, salimos del editor. 5) Damos al archivo prog1 permiso de ejecución. $ chmod u+x prog1 6) Ejecutamos el programa, igual que lo hacemos con cualquier otro.

¿Qué puede pasar? En caso de que el directorio actual no esté incluido en el PATH será necesario invocar el shell script anteponiendo la cadena ./ y a continuación sin espacio en blanco el nombre del programa. Los comentarios comienzan con el carácter #. Si queremos que los caracteres especiales como $ o ? no sean interpretados por la shell debemos anteponer la backslash \.

El comando read Utilidad: leer información escrita en la línea de comandos de forma interactiva. Si hay más variables en la orden read que palabras escritas, las variables que sobran por la derecha se asignarán a NULL. Si se introducen más palabras que variables haya, todos los datos que sobran por la derecha se asignarán a la última variable de la lista. El siguiente ejemplo lee una variable desde el teclado y la muestra por pantalla:

####################################### # Programa que lee desde la entrada estándar # ####################################### echo –n Ingrese un valor: read var #se pueden poner más variables echo La variable ingresada es: $var Ejercicio: Crear un programa que lea tres variables y las muestre por pantalla una debajo de la otra. Probarlo con 3 variables, luego con 2 y por último con 4.

Comando expr Sintaxis: expr arg1 op arg2 [op arg3…..] Los argumentos de este comando se toman como expresiones y deben ir separados por blancos. Expr evalúa sus argumentos y escribe el resultado en la salida estándar. El uso más común de expr es para efectuar operaciones aritméticas simples, y en menor medida para manipular cadenas (averiguar la longitud de una cadena, filtrar determinados caracteres de una cadena, etc)

Operadores aritméticos + Suma arg2 a arg1 Resta arg2 a arg1 * Multiplica los argumentos / Divide arg1 entre arg2 (división entera) % Resto de la división entera entre arg1 y arg2. En el caso de usar varios operadores, las operaciones de suma y resta se evalúan en último lugar, a no ser que vayan entre paréntesis. No olvidar que los símbolos como el * tienen un significado especial, por lo que deben ser precedidos por el símbolo backslash o encerrados entre comillas simples.

Ejercicio Crear el programa multi que efectúa la multiplicación de dos variables ingresadas desde el teclado. echo –n Ingrese primer valor: read v1 echo –n Ingrese segundo valor: read v2 result=`expr $v1 \* $v2` echo $v1 \* $v2 = $result

El comando let Otra manera de realizar operaciones aritméticas es mediante el uso del comando let. La forma más directa de entender cómo funciona let es a través de un ejemplo: num=5 let num2=$num*8 echo $num2

Operadores relacionales En Linux tenemos 2 tipos de operadores relacionales que quieren decir lo mismo pero tienen usos diferentes. Para realizar comparaciones de cadenas de caracteres los operadores relacionales son: =; !=; >; >=; < y <= Aquí el operador > aplicado entre dos argumentos que son cadenas de caracteres, quiere decir que el elemento que está a la izquierda está ubicado después que el que está a la derecha, alfabéticamente.

Operadores relacionales aritméticos Para diferenciar un caso de otro Linux nos proporciona operadores relacionales aritméticos. Operadores -lt (<) -ge (>=) -gt (>) -eq (==) -le (<=) -ne (!=)

Ejercicios Escribir un programa que pida al usuario dos números por pantalla, los muestre y realice la suma de los mismos. Escribe un programa que pida dos variables y devuelva 1 si son iguales o 0 si son distintas. Pista: puede utilizar expr, igual que en el ejemplo anterior y recuerde que el resultado de la comparación es 1 si se cumple la condición planteada o 0 si no se cumple. Modifica el programa anterior para comprobar si el primer número es mayor que el segundo.

Evaluaciones Sirven para averiguar el valor lógico de una expresión. Generalmente se combina con una instrucción de bifurcación como if. Test para archivos: Sintaxis: test –opción argumento Test evalúa expresiones y genera un valor de retorno que no se escribe en la salida estánar, pero asigna 0 si la expresión es verdadera o 1 si es falsa. Test puede evaluar 3 tipos de elementos: archivos, cadenas y números. Si usamos paréntesis rectos hay que dejar espacio tanto a la izquierda como a la derecha de la expresión.

Opciones: f Devuelve 0 si el archivo existe y es un archivo común. s Devuelve 0 si el archivo existe y su tamaño es > 0. r Devuelve 0 si el archivo existe y tiene permiso de lectura. Para evaluar cadenas: Sintaxis: test cadena1 operador cadena2 Ó [cadena1 operador cadena2] Ejemplos: a=palabra1 [ $a = palabra2] echo $? Probarlo e interpretar.

De esta manera podemos evaluar si dos cadenas son iguales o no. test para evaluaciones numéricas Sintaxis: test número1 operador número2 ó también [ número1 operador número2 ] Este comando es sólo valido con números enteros. Los operadores usados para comparar números son: -lt Menor que -le Menor o igual que -gt Mayro que -ge Mayor o igual que -eq Igual a -ne No es igual a

Ejemplos a=23 [ $a –lt 55 ] echo $? Probarlo test $a != 23

Comando sleep sleep n° segundos Utilidad: Hace una pausa durante un número determinado de segundos antes de continuar con lo siguiente. Sintaxis: sleep n° segundos

Estructura condicional if Sintaxis: if condición1 then acciones else fi

Ejemplo if de comparación de cadenas #! /bin/bash palabra=geoda read –p “Ingrese una palabra: “ pal if [ $pal \> $palabra ] then echo La cadena es alfabéticamente posterior. else if [ $pal \< $palabra ] echo La cadena es alfabéticamente anterior. echo Las palabras son iguales. fi

Ejemplo if operadores aritméticos Crear un programa que me avise si el número ingresado es mayor, menor o igual a 10. #! /bin/bash clear read –p “Ingrese un valor: “ op if [ $a -gt 10 ] then echo El número ingresado es mayor a 10 else if [ $a -lt 10 ] echo el número ingresado es menor a 10 echo el número ingresado es 10. fi

Ejercicio Crear un programa que le pida a un usuario que ingrese el número 1 para realizar la suma de 2 valores o el número 2 para realizar la resta de los mismos.

Solución #! /bin/bash clear read –p “Ingrese 1 para sumar o 2 para restar: “ op if [ $op -eq 1 ] then read –p “Ingrese primer valor: “ a read –p “Ingrese segundo valor: “b else sum=`expr $a + $b` # ó let sum=$a+$b echo el resultado de la suma es $sum SIGUE 

if [ $op -eq 2 ] then read –p “Ingrese primer valor: “ a read –p “Ingrese segundo valor: “ b res=`exp $c - $d` # ó let res=$a-$b echo El resultado de la resta es $res else echo No ha ingresado un valor válido fi sleep 1

Case case expresión in caso 1) comandos;; caso 2) comandos;; …….. *) default;; esac

Ejemplo de case con menu #! /bin/bash clear echo “ MENU 1) Listar archivos comunes 2) Listar directorios “ read –p “Ingrese la opción deseada: “ op SIGUE 

Ejemplo de case con menú case $op in 1) ls –l | grep ^-;; 2) ls –l | grep ^d;; *) echo Opción inválida;; esac sleep 2

Ejercicio de case Escribir un programa que despliegue un menú en pantalla y le pida a un usuario que elija 1 de las operaciones matemáticas básicas. Si la opción ingresada no es válida el programa deberá terminar su ejecución, avisando al usuario del problema.

WHILE Sintaxis: while condición do orden (es) done

La ejecución del while es: Se evalúa la condición Si el código devuelto por la condición es 0 (verdadero), se ejecutará la orden u órdenes y se vuelve a iterar. Si el código de retorno de la condición es falso, se saltará la primera orden que haya después de la palabra done.

Ejemplo #! /bin/bash a=42 while [ $a –le 53 ] do echo Contador = $a a=`expr $a + 1` done

Ejercicio Modifique el ejercicio de las operaciones aritméticas para que un usuario pueda hacer todas las operaciones que quiera, hasta que ingrese un valor de terminación.

Respuesta: Es muy fácil: Hay que poner el while al principio, con la siguiente condición: [ “$op” != 0 ], porque aún no hemos ingresado la opción y las comillas quieren decir cadena vacía. Una cosa es poner cadena vacía y otra cosa es no poner nada. Si no hay comillas larga error. Luego va el do, todo el programa en el medio, agregando una opción para el cero por ejemplo. Y al final de todo el done.

Incrementar un contador con let #! /bin/bash cont=0 max=20 while [ $cont –lt $max ] do let cont=cont+1 echo el contador es $cont done

Sobre las condiciones de las estructuras La condición de un if puede ser en realidad cualquier comando. El resultado de la ejecución de ese comando se guarda en una variable especial del sistema que se llama ?. Y esta variable toma el valor 0 si el comando tiene éxito y distinto de 0 si no tiene éxito. Veámoslo con un ejemplo:

Otro ejemplo de if if cp /home/pepe/* . then echo se copió correctamente else echo error fi

Otro ejemplo del mismo estilo if grep $nom agenda.txt then echo el nombre ya existe. ……… else echo –n Ingrese apellido: fi

Sobre la sintaxis del case case $ op in casa | CASA) acciones;; 3) acciones;; [a-z]) acciones;; *) acciones esac Nota: como acabamos de ver podemos poner lo que queramos en los casos del case, y no necesariamente 1, 2, 3, etc.