Este documento trata sobre programación de shell scripts en Linux. Explica conceptos básicos como variables de entorno, variables de usuario, operadores aritméticos y de comparación, estructuras condicionales como if y case, y bucles como while. También cubre comandos como expr, let, test y read que permiten realizar cálculos, comparaciones y leer entrada de usuario de forma interactiva en los scripts.

1. PROGRAMACIÓN DE SHELL
SCRIPTS
1

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

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

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

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

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

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

8. Ejercicios
1) 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.
2) 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.
8

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

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

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

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

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

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

15. Primer programa
1) Elegir un nombre para el programa.
2) Editarlo con vi. Ej. vi prog1
3) 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. 15

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

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

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

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

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

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

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

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

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

25. Ejercicios
1) Escribir un programa que pida al usuario dos
números por pantalla, los muestre y realice la
suma de los mismos.
2) 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.
3) Modifica el programa anterior para comprobar si el
primer número es mayor que el segundo.
25

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

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

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

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

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

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

32. 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 ]
then
echo La cadena es alfabéticamente anterior.
else
echo Las palabras son iguales.
fi
fi 32

33. 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 ]
then
echo el número ingresado es menor a 10
else
echo el número ingresado es 10.
fi
fi 33

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

35. 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
else
35
SIGUE 

36. 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
fi
sleep 1 36

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

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

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

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

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

42. La ejecución del while es:
1) Se evalúa la condición
2) Si el código devuelto por la condición es 0
(verdadero), se ejecutará la orden u órdenes y se
vuelve a iterar.
3) 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. 42

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

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

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

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

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

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

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

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