TEMA 6: Programación Shell

ADMINISTRACIÓN DE SISTEMAS OPERATIVOS

Contenido

• Shell scripts
• Ejecución de scripts
• Parámetros y variables
• Sentencias condicionales
• Bucles
• Funciones

2
¿Qué es un script?

• El Shell es un interprete de comandos que permite ejecutar una serie de

ordenes y la interacción de los usuarios con el sistema.

• Pero también es mucho más que eso: es un lenguaje de programación

en el que cada instrucción se ejecuta de forma secuencial como un
comando.

• Un shell script es un fichero de texto que contiene un conjunto de

comandos y órdenes interpretables por el Shell, no ejecutables.

• Es habitual que los shell scripts tengan la extensión ".sh" para ayudar a la
identificación del contenido a partir del nombre del archivo.

3
Bourne Again Shell (Bash)

• Shell más moderno y más utilizado en sistemas GNU/Linux.

• Superconjunto de Bourne Shell (sh). Todos los scripts sh se pueden

ejecutar en bash, pero no al contrario!

• Además posee una serie de ventajas como:

• definición de alias
• ejecución síncrona y paralela
• incorporación de operadores de lenguaje de alto nivel
• control de trabajos, etc.

4
 Sintaxis de un script shell

primer_script.sh
Shebang
#!/bin/bash
# Esto es un comentario y no se interpreta Comentario
echo "Buenas ASO. Vamos a ejecutar el comando ps aux:"
ps aux | grep bash
Ordenes

5
 Shebang

• El shebang permite especificar el intérprete de comandos con el que deseamos que

sea interpretado el resto del script cuando se usa invocación implícita.

• Es imprescindible que el shebang se encuentre en la primera línea del script, ya que,

en caso contrario, sería interpretado como un comentario (comienza con el carácter
#).

• El shebang no es obligatorio, pero es recomendable. Si no se indica en invocación

implícita se intentará usar el mismo tipo de shell desde el que se ha invocado el
script.

• Para consultar la Shell por defecto se puede utilizar el siguiente comando:

• $ echo $SHELL

6
Ejecución de scripts
• Explícita: escribiendo explícitamente qué shell se desea invocar. Esto creará un nuevo proceso
en memoria para dicha Shell. En este caso se ignora el shebang. Ejemplos:
• /bin/sh primer_script.sh
• /bin/dash primer_script.sh
• /bin/bash primer_script.sh

• Implícita: invocando al script como si fuera un ejecutable, lo que requiere asignar permisos de
ejecución al script. Se lee el shebang para determinar qué shell deberá usarse para leer el
script, cargándose en memoria un proceso hijo (subshell) para dicha Shell.
• ./primer_script.sh

• Implícita con “.” o con source: el script será interpretado por el mismo proceso del shell
responsable de la línea de comandos desde la que se está invocando el script (luego aquí no se
abre ningún subshell). Script interactivo. En este caso también se ignora el shebang.
• . primer_script.sh
• source primer_script.sh

7
Parámetros y variables en Shell
• Hay tres tipos de parámetros en Shell:

1. Si el nombre es un número se denominan parámetros posicionales.

2. Si el nombre es un carácter especial se denominan parámetros especiales.

3. El resto son variables.

8
 Parámetros posicionales
• Los parámetros posicionales son los encargados de recibir los
argumentos de un script y los parámetros de una función.

• Para acceder a ellos utilizamos el símbolo $ seguido de la posición del

parámetro. Ejemplo: $1, $2, $3, etc.

• El parámetro posicional 0 almacena el nombre del script donde se ejecuta, o

la Shell si se ejecuta directamente.
• [Link]
#!/bin/bash

# Ejemplo de script que recibe parametros y los imprime

echo "El script $0"
echo "Recibe los argumentos $1 $2 $3 $4"

9
Parámetros especiales
Se expande a todos los parámetros posicionales
desde el 1. Si se usa dentro de comillas dobles, se
$* expande como una única palabra formada por los
parámetros posicionales separados por el primer
carácter de la variable IFS.
Se expande a todos los parámetros posicionales
$@ desde el 1, como campos separados, incluso
aunque se use dentro de comillas dobles.

Opciones actuales del shell (modificables con el

$- comando set). Consulte las opciones disponibles
con el comando man dash .
Nº de argumentos pasados al script (no incluye el
$#
nombre del script).

Valor devuelto por el último comando, script,

$?
función o sentencia de control invocado.

PID del proceso shell que está interpretando el

$$
script.
$! PID del último proceso puesto en segundo plano.

10
 Parámetros especiales
• [Link]

#!/bin/bash

IFS=','
echo "El script $0 con PID $$ recibe $# argumentos: $*"
echo "El script $0 con PID $$ recibe $# argumentos: $@"
echo "El ultimo proceso puesto en segundo plano es $!"
echo "El ultimo valor devuelto es $?"

11
 Variables
• No es necesario definir las variables previamente a su uso, ya que se
crean al asignarles un valor la primera vez.

• Al definir una variable sin inicialización, su valor por omisión es la

cadena nula. Las siguientes entradas son equivalentes:
• VAR=
• VAR=""

• Por defecto, todas las variables son tratadas por defecto como
cadenas de caracteres.

12
 Variables
• Es importante no incluir ningún espacio ni antes ni después del signo =. Si se hace, el shell
intentará interpretar el nombre de la variable como un comando:
• VAR=5 # Asignación correcta
• VAR = 5 # Comando VAR

• Para acceder al valor de una variable utilizamos el símbolo $:

• $VAR
• ${VAR}

• Para declarar variables de tipo entero usamos la opción declare:

• declare -i VAR
• VAR=1
• VAR=VAR+1
• echo $VAR

13
 Variables
[Link] Atención:
Para eliminar la variable VAR, hacemos unset VAR.
#!/bin/bash
Si hacemos . [Link] (y no hacemos unsets) la
salida puede ser diferente porque se ejecuta en el
VAR = 1
proceso padre.
VAR=1 Sin embargo, con ./[Link] se crea un proceso
declare -i var=3 hijo donde las variables VAR y var no existen.

echo "Variables: $VAR $var"

VAR=$VAR+1
var=var+1
echo "Variables: $VAR $var"
echo "Variable VAR seguida de 1 (requiere llaves): ${VAR}1"
echo 'Comillas simples: $VAR'
echo "Valor: $VAR-1"

14
 Operadores de cadena
• Los operadores de cadena nos permiten manipular cadenas sin necesidad
de escribir rutinas de procesamiento de texto.

• En particular los operadores de cadena nos permiten realizar las siguientes

operaciones:
• Asegurarnos de que una variable existe (que está definida y que no es nula).
• Asignar valores por defecto a las variables.
• Tratar errores debidos a que una variable no tiene un valor asignado.
• Coger o eliminar partes de la cadena que cumplen un patrón.

15
 Operadores de cadena. Asignación
• $ {var:-dato} Si var existe y no es nula retorna su valor, si no, retorna dato.

• ${var:+dato} Si var existe y no es nula retorna dato, si no, retorna una cadena nula.

• ${var:=dato} Si var existe y no es nula retorna su valor, si no, asigna dato a var y retorna
su valor.

• ${var:?mensaje} Si var existe y no es nula retorna su valor,

si no, imprime var:mensaje y aborta el script que se esté ejecutando (sólo en shells no
interactivos).

16
 Operadores de cadena. Asignación
[Link]

#!/bin/bash

unset VAR
echo 1: ${VAR:-1}
VAR=2
echo 2: ${VAR:+3}
unset VAR # eliminamos la variable VAR
echo 3: ${VAR:=4}
echo 4: $VAR
unset VAR
${VAR:?variable no declarada}
echo Adios

17
 Operadores de cadena. Búsqueda de patrones
• ${var%sufijo} Elimina el sufijo más pequeño del valor de la variable. Si en vez de % se pone %%
se elimina el sufijo más grande.

• ${var#prefijo} Elimina el prefijo más pequeño del valor de la variable. Si en vez de # se pone ##
se elimina el prefijo más grande.

• ${var:offset:longitud} Retorna una subcadena de var que empieza en offset y tiene longitud
caracteres. Si se omite longitud la subcadena empieza en offset y continua hasta el final de var.

18
 Operadores de cadena. Búsqueda de patrones
[Link]

#!/bin/bash

TEXT="ASO 1 ASO2021 ASODECEMBER"

echo ${TEXT%A*}
echo ${TEXT%%A*}

FICH=/usr/bin/aso
echo ${FICH#*/}
echo ${FICH##*/}

echo ${TEXT:6:8}

19
 Sustitución de comando
• Permite que la salida estándar de un programa se utilice como parte de una
variable u otro comando.

• Existen dos opciones, con el mismo funcionamiento:

• $(comando)
• `comando`

• Por ejemplo, para almacenar en una variable el nombre de todos los ficheros con
extensión .sh del directorio actual, podría escribir:
• VAR=`ls *.sh`

• O, por ejemplo, para matar el proceso con nombre “python”, podría usar:
• kill -9 $(pidof python)

20
Sustitución de comando
sus_comando.sh

#!/bin/bash

echo El directorio $1 tiene $(find $1 -type d | wc -l) directorios

echo Y $(find $1 -type f | wc -l) ficheros
file $(find $1 -name "*.sh" -type f)

21
 Expansión aritmética
• Permite evaluar las cadenas indicadas en la expresión como enteros,
admitiendo gran parte de los operadores usados en el lenguaje C.
$ VAR=1+1
• Tras la evaluación aritmética, el resultado vuelve a ser convertido a una $ echo VAR
cadena. VAR
$ echo $VAR
1+1
• El formato para realizar una expansión aritmética es el siguiente:
• $((expresion))
$ echo $(($VAR+1))
3
• Ejemplo: //no hay necesidad de
• $(($VAR+1))
//poner $ dentro de
//los paréntesis
• Si se usan variables en la expresión, no es necesario que vayan precedidas $ echo $((VAR+1))
por el carácter $ si ya contienen un valor entero válido. 3

• Otra forma de expansión aritmética es usar el operador let $ let VAR=1+1

• let VAR=2+5 $ echo $VAR
2

22
 Expansión aritmética
[Link]

#!/bin/bash

VAR=1
VAR=$VAR+1
echo $VAR
RES=$(($VAR))+1
echo $RES
let RES=$RES+1
echo $RES
VAR1=b
echo $(($VAR1+1)) // b se es tratado como 0

23
 Sentencias condicionales
• La sentencia condicional (verdadera con 0) tiene el siguiente formato:
if condicion
then
sentencias
elif condicion
then
sentencias
else
sentencias
fi
• Es equivalente a:
if condicion ; then
sentencias
elif condicion ; then
sentencias
else
sentencias
fi
• También se puede poner todo en una línea:
• if condicion; then sentencias; elif condicion; then sentencias; else sentencias;

24
 Sentencias condicionales
[Link]

#!/bin/bash

if [ -f $1 ]; then
echo el fichero $1 existe
else
echo fichero no encontrado
fi

25
Sentencias condicionales. Case
• La estructura case se puede utilizar directamente con cadenas de
caracteres, al contrario que otros lenguajes de programación.
• El doble punto y coma ;; permite determinar el final de los elementos a
interpretar cuando se cumpla su patrón asociado. Por ese motivo, el ;; del
último patrón puede omitirse.

case cadena_texto in
patron1) lista-compuesta1;;
patron2) lista-compuesta2;;
...
* ) lista-defecto [;;] #coincide con todo
esac

26
 Sentencias condicionales. Case
[Link]

#!/bin/bash

case $1 in
[Link])
echo Prueba case correcta! ;;
*.c)
echo Fichero C ;;
*)
echo Default. Pruebe otro
esac
27
Operadores lógicos
• Podemos combinar varios códigos de terminación de comandos mediante
los operadores lógicos and (representada con &&) or (representada con ||)
y not (representada con !).

• Estas operaciones, al igual que en otros lenguajes como C o Java, funcionan

en cortocircuito, es decir el segundo operando solo se evalúa si el primero
no determina el resultado de la condición.

if cp /tmp/[Link] ~/[Link] || cp /tmp/[Link] ~/[Link]

then
····
fi

28
 Test condicionales
• La sentencia if lo único que sabe es evaluar códigos de terminación. Pero
esto no significa que sólo podamos comprobar si un comando se ha
ejecutado bien.

• Podemos utilizar el operador [] dentro del cual metemos la condición a

evaluar.

• Los espacios entre los corchetes y los operandos, o entre los operandos y el
operador de comparación = son obligatorios.

• Ejemplo:
• [ cadena1 = cadena2 ]

29
Test condicionales. Comparación de cadenas
• Las comparaciones que realizan < y > son lexicográficas, es decir
comparaciones de diccionario, donde por ejemplo "q" es mayor que
"perro".
• No existen operadores <= y >= ya que se pueden implementar mediante
operaciones lógicas.

30
 Test condicionales. Comparación de enteros
• El shell también permite comparar variables que almacenan cadenas interpretando estas cadenas
como números.

31
Test condicionales. Comparación de ficheros
• El tercer tipo de operadores de comparación nos permiten comparar
atributos de ficheros. Existen múltiples operadores de este tipo:

32
 Test condicionales
[Link]

#!/bin/bash

if [ $# -eq 0 ]; then
echo Falta el nombre del fichero
else
if [ -f $1 ]; then
if [ -x $1 ]; then
echo El fichero $1 es ejecutable
else
echo El fichero $1 NO es ejecutable
fi
else
echo El argumento $1 no es un fichero
fi
fi
33
 Test condicionales
• Se permite crear condiciones múltiples mediante los operadores:

• condicion1 -a condicion2
• AND: Verdadero si ambas condiciones son verdaderas
• condicion1 -o condicion2
• OR: Verdadero si se cumple alguna de las dos condiciones

• Ejemplo: el fichero existe y podemos leerlo y se puede modificar:

• [ -r $FILE -a -w $FILE ];

• Ejemplo: el fichero existe o es un enlace simbólico:

• [ -e $FILE -o -h $FILE ];

34
 Ejercicio de clase
• Ejecuta este script con source o ‘.’

• Compruebe que se le pasa al menos un parámetro, en caso contrario termina

(return) el script con código 1.

• Compruebe que se le pasa un directorio como argumento, en caso contrario

termina con código 2.

• Si se le pasa un directorio, debe comprobar que no es el directorio actual y que

tiene permisos de búsqueda, en caso contrario devuelve el código 3. En caso
afirmativo, nos desplazamos hacia él.

35
 Bucles. For
• El bucle for en Bash es un poco distinto a los bucles for tradicionales de otros
lenguajes como C o Java, sino que se parece más al bucle for each de otros
lenguajes, ya que aquí ́ no se repite un numero fijo de veces, sino que se procesan
las palabras de una frase una a una.

• La estructura for define la variable “i” si no ha sido previamente definida.

• lista_valores se corresponde con un conjunto de valores (tomándose cada valor

como una cadena de caracteres que puede ser objeto de expansión y como
caracteres de separación los caracteres definidos en la variable IFS).

for i in lista_valores; do
sentencias
done

36
Bucles. For
bucle_for.sh

#!/bin/bash

for i in 1 2 3; do
echo "Iteracion: $i"
done

for file in $(ls $1); do

echo "Fichero: $file"
done

for i in $(seq $2 1 $3); do

echo "Iteracion: $i"
done

37
Ejercicio de clase
• Desarrolle un script que liste todos los ficheros
ejecutables que haya en un directorio pasado como
argumento.

38
Bucles. While y until
• While se ejecuta mientras que el código de terminación del comando sea
exitoso, es decir 0, mientras que until se ejecuta hasta que el código de
terminación sea exitoso.
• Until se puede interpretar como ejecutar varias veces un comando hasta
que tenga éxito.
while condicion; do
sentencias
done

until condicion; do
sentencias
done

39
Bucles. While y until
• bucles_while_until.sh

#!/bin/bash

let CONTADOR=0
while [ $CONTADOR -lt 10 ]; do
echo El contador while es $CONTADOR
CONTADOR=$CONTADOR+1
done

let CONTADOR=0
until [ $CONTADOR -ge 10 ]; do
echo El contador until es $CONTADOR
CONTADOR=$CONTADOR+1
done
40
 Funciones
• El formato de una función en bash es el siguiente:
nombrefuncion () {
comandos bash ···
}

• El paréntesis siempre debe estar vacío (sólo indica que se está definiendo una función).
Pueden insertarse espacios antes, entre y después del paréntesis

• Cuando definimos una función se almacena como una variable de entorno (con su valor
almacenando la implementación de la función).

• Las funciones reciben parámetros posicionales de la misma forma que un script y sólo pueden
devolver enteros.

• Para ver una función definida declare –f nombrefn. Para borrar una función podemos usar el
comando unset -f nombrefn.

41
Funciones
• [Link]

#!/bin/bash

suma () {
RES=$(($1+$2))
echo "Suma: $RES"
return $RES
}
suma 2 3
suma $1 $2 #suma los 2 primeros argumentos pasados al script
echo "Valor devuelto de la ultima suma: " $?

42
 Ejercicio de clase
• Sabiendo que el operador ${#var} devuelve el tamaño de una cadena, y
utilizando el operador para obtener una subcadena $ {var:offset:longitud},
cree una función Reverse que devuelva a través de variable global una
cadena de caracteres invertida.

43
 Variables globales y locales
• Las variables de un script se liberan después de su ejecución si utilizamos
scripts no interactivos.

• Por defecto, todas las variables que definimos en un script o función son
globales, es decir, una vez definidas en el script son accesibles (y
modificables) desde cualquier función.

• Si queremos que una variable no posicional sea local debemos utilizar el

modificador local, el cual sólo se puede usar dentro de las funciones (no en
los scripts). Ejemplo:
• local var=2

44
 Variables globales y locales
[Link]

#!/bin/bash

CheckVar () {
var='Dentro de la funcion'
}
var='En el script'
echo $var
CheckVar
echo $var

echo Ejemplo usando variables locales

LocalCheckVar () {
local var='Dentro de la funcion'
}
var='En el script'
echo $var
LocalCheckVar
echo $var

45
Bibliografía
• Programación Shell-script:
[Link]
• Shell Command Language:
[Link]
[Link]
• Shell Script: [Link]

46