Sistemas Operativos Monousuario y Multiusuario 1º ESI

EL SHELL BASH

El shell es un programa que se lanza automáticamente cuando un usuario se

conecta al sistema a través de una terminal de texto.

shell
Sistema Linux usuario

El término shell en inglés significa “concha”, lo que se corresponde con la imagen

de encapsulación que realmente representa.

El shell se llama también “intérprete de comandos” porque:

− es quien traduce al sistema las instrucciones sometidas por el usuario

mediante la línea de comandos y quien presenta la información devuelta en
pantalla.
− A diferencia de un compilador utilizado en programación (que construye un
archivo binario comprensible por el núcleo Linux a partir de una serie de
instrucciones contenidas en el código fuente), el shell interpreta y ejecuta cada
comando a medida que el usuario los escribe.

Existen muchos shells disponibles para Linux; destacan:

− Bourne shell o sh: es el primer shell escrito para Unix por Steve Bourne. Hoy
obsoleto, muchos intérpretes de comandos recientes conservan la
compatibilidad con él. El programa correspondiente es sh o bsh.
− Korn Shell o KSH: es uno de los intérpretes de comandos más utilizados en el
mundo Unix. Es compatible con el shell Bourne original. Existe una
implementación libre de éste: el “Public Domain KSH”. El binario
correspondiente en Linux es pdksh.
− C shell: este shell fue desarrollado por la rama BSD de Unix y usa una sintaxis
diferente a los anteriores. Puede lanzarse mediante el programa csh.
− tcsh: es una implementación mejorada del C shell que dispone de una edición
avanzada de la línea de comandos. Su ejecutable es tcsh.
− Bash o Bourne Again Shell: como su nombre indica, es una nueva
implementación del shell Bourne y se parece mucho al Korn shell. Muy
funcional, es el intérprete de comandos predeterminado en Linux que se
detalla en el resto del tema. El programa correspondiente es bash.

El shell de DOS es el COMMAND.COM. Y su programación en DOS es BATCH.

Shell Scripts Página 1 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

Los caracteres especiales tienen un significado particular para el shell en la línea

de comandos. Se distinguen varias categorías de caracteres especiales:

− los metacaracteres incluyen los caracteres separadores en la línea de

comandos: <, >, |, (, ), ;, &, espacio, retorno de carro (tecla Intro) y tabulación;
− los caracteres genéricos que permiten la creación de comodines de reemplazo
en los nombres de archivo: *, ? y [];
− Los caracteres utilizados en las sustituciones de variables y comandos: $, ` y {};
− los caracteres de cita: \, “ y '.

Algunos de estos caracteres pueden tener diferentes significados según el

contexto en el que aparezcan.

El significado de cada uno de estos caracteres se estudia más adelante.

VARIABLES

Una variable es un parámetro que puede cambiar durante la ejecución de un

programa; se le da un nombre para recuperar el valor que representa.

Manipulación de variables

Nombrado

El nombre de una variable es una palabra compuesta exclusivamente por

caracteres alfanuméricos y el subrayado _ (underscore), empezando por una letra
o un subrayado.

Por convención, el usuario llamará a las variables con nombres en minúscula, ya la

los nombres en mayúsculas hacen referencia a las variables de entorno.

Es conveniente dar nombres explícitos a las variables para facilitar el

mantenimiento de los scripts.

Asignación

Una variable llamada var puede recibir un valor por una asignación de la forma
var=valor.

No hay ningún espacio antes ni después del carácter = y si el valor se compone de

varias palabras o caracteres especiales debe ir enmarcado entre caracteres de cita.

Una variable existe desde que se le asigna un valor; este valor puede ser un nº, un
carácter, una palabra o una cadena de caracteres con cualquier carácter especial:

Ej:

Shell Scripts Página 2 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

var1=12 var2=palabra var3= “dos palabras”

var4='car. especiales: $* ?{}()[]”&'

Si no se proporciona ningún valor, la variable recibe una cadena vacía; las dos
sintaxis siguientes son equivalentes:

var5=”” var6=

Llamada y visualización

El shell reemplaza una variable por su valor si su nombre precedido por el

carácter $ aparece en la línea de comandos, antes incluso de interpretar el
comando escrito:

[alumno]> echo $var2

palabra

La llamada a un nombre de variable no definida no genera errores; el shell se

limita a reemplazarla por la cadena vacía.

Si al utilizar el valor de una variable, el nombre de variable esta seguido de un

carácter que sea otra letra, numero o el símbolo '_', tendremos que utilizar los
símbolos '{}' alrededor del nombre de la variable.; por ejemplo:

[alumno]> var7=registro
[alumno]> echo contenido de la variable var7: $var7
contenido de la variable var7: registro
[alumno]> echo el archivo es: $var7_2006.txt
el archivo es:
[alumno]> echo el archivo es: ${var7}_2006.txt
el archivo es: registro_2006.txt

El comando set llamado sin argumentos muestra la lista completa de las variables
definidas en el shell actual.

Visibilidad de una variable

De modo predeterminado, toda variable sólo se define en al shell donde se ha

creado; es decir, sólo es accesible desde los subprocesos del shell y se destruye al
finalizar la ejecución de dicho shell.

[alumno]> x=3
[alumno]> echo $x
3
[alumno]> bash
[alumno]> echo $x

[alumno]> x=7
[alumno]> echo $x
Shell Scripts Página 3 de 32
Sistemas Operativos Monousuario y Multiusuario 1º ESI

7
[alumno]> exit
[alumno]> echo $x
3

El comando export especifica al shell que una variable debe copiarse en el

entorno de todos los procesos hijos del shell actual. Este comando puede
utilizarse junto con la asignación de una variable:

[alumno]> export x=3

[alumno]> echo $x
3
[alumno]> bash
[alumno]> echo $x
3
[alumno]> x=7
[alumno]> echo $x
7
[alumno]> exit
[alumno]> echo $x
3

El argumento del comando export es el nombre de la variable y no su contenido,

por lo tanto no debe ir precedido del carácter $.

Borrado

Una vez que una variable existe, solo puede destruirse utilizando el comando
unset. Por ejemplo: unset var2.

Variables de Entorno

Las variables de entorno afectan al comportamiento del shell y de la interfaz de

usuario. Se definen al cargar el shell y pueden listarse mediante el comando set
visto anteriormente.

Aunque se pueden modificar como cualquier otra variable, la asignación de valres

erráticos a las variables de entorno puede llevar a un comportamiento “aleatorio”
del shell y los comandos lanzados desde él.

Los nombres de estas variables generalmente van en mayúsculas.

Vamos a presentar sólo las principales.

$BASH: Ruta al propio binario Bash.

$BASH_ENV: Variable que apunta al archivo de arranque Bash. Se lee al
arrancar cada script para reinterpretar este archivo de comandos.
$EDITOR: Nombre del editor predeterminado invocado por otras
herramientas en línea de comandos; generalmente es la ruta absoluta de vi
Shell Scripts Página 4 de 32
Sistemas Operativos Monousuario y Multiusuario 1º ESI

o emacs.
$HOME: Ruta completa del directorio personal del usuario conectado
actualmente.
$IGNOREEOF: Indica el nº de veces que el shell ignorará el carácter de fin de
archivo (EOF) pasado mediante las teclas [Ctrl]+[d] antes de terminar.
$OLDPWD: Directorio donde se encontraba anteriormente el usuario. Esta
variable la usa el comando cd -.
$PATH: Lista de directorios separados por el carácter : (dos puntos) con los
ejecutables del sistema (binarios, scripts shell). Cuando se da un comando,
el shell busca automáticamente los ejecutables en los directorios listados en
esta variable, por orden de lista.
Para agregar un directorio a esta lista, se usa la sintaxis siguiente:
PATH=$PATH:/nuevo_directorio

$PS1: Este es el prompt principal, visto desde la línea de comandos

El prompt del shell Bash puede estar compuesto por secuencias de
caracteres que representan diversas informaciones; el uso de
apóstrofes es necesario para asignar esta variable. Las principales
secuencias de caracteres son:

\a Emite un bip al mostrar el símbolo del sistema

\d Muestra a fecha
\h Muestra el nombre del equipo
\H Muestra el nombre completo del equipo
\t Muestra la hora actual
\u Muestra el nombre del usuario conectado
\w Muestra la ruta del directorio actual
\W Muestra el nombre del directorio actual

$PS2: Esta variable representa el símbolo del sistema secundario que se

muestra cuando el shell espera el resto de la entrada de un comando.
$PWD: Directorio actual donde se encuentra el usuario.
$TMOUT: Si esta variable de entorno se inicia con un valor numérico
distinto de cero, el shell se desconecta automáticamente al cabo del número
de segundos indicado aquí, en caso de inactividad por parte del usuario.
Al igual que un protector de pantalla con contraseña, esto evita que un
usuario deje abierta su sesión inadvertidamente.

CARACTERES GENÉRICOS

* Sustituye cualquier grupo de caracteres, excepto cuando el primero del

grupo es un punto.
? Sustituye cualquier carácter excepto el punto del principio de un nombre de
archivo.
[] La sintaxis [lista_de_caracteres] en un motivo representa un carácter (y solo
uno) entre los propuestos en la lista. Por ejemplo, [abc] se reemplaza por
una a, una b o una c. Ejemplo: ls ?[ol]* (rosado rojo blanco). También admite
rangos como [b-e] similar a [bcde]. [a-zA-Z]. Si el primer carácter de la lista
es un signo de exclamación ! o un acento circunflejo ^, la correspondencia
Shell Scripts Página 5 de 32
Sistemas Operativos Monousuario y Multiusuario 1º ESI

se hace con cualquier carácter ausente de la lista, [!ar]* sería aquellos

nombres que no comiencen ni por a ni por r. Si queremos incluir los
caracteres ! ^ en la lista habrá que ponerlos en cualquier lado de la lista
excepto al principio.
Existen ciertas clases de caracteres predefinidas:
[:alnum:] Equivale a [A-Za-z0-9]
[:alpha:] Equivale a [A-Za-z]
[:digit:] Equivale a [0-9]
[:graph:] Equivale a [:print:] pero sin carácter de espacio.
[:lower:] Equivale a [a-z]
[:print:] Equivale a caracteres comprendidos entre ASCII 32 y ASCII 126
[:space:] Cualquier espacio en blanco (espacio, tabulación)
[:upper:] Equivale a [A-Z]
[:xdigit:] Equivale a [0-9A-Fa-f]. Corresponde a cifras hexadecimales.

Ejemplo: Nombres cuyo último carácter sea una cifra: ls *[[:digit:]]

{} A la manera de los corchetes que ya hemos visto para la creación de listas
de caracteres, las llaves permiten especificar listas de motivos separadas
por una coma en un motivo de reemplazo. La sintaxis {abc, def}, se
reemplaza por la cadena abc o la cadena edf. Ejemplos: ls {az, ro}* (azul
rosado rojo) o ls {*ro[sj]*,?a*} (banco rosado rojo).

CARACTERES DE CITA

Los caracteres de cita se utilizan para modificar la interpretación del shell de

otros caracteres. Así, un carácter especial puede interpretarse literalmente y no de
forma simbólica.

Los comandos grep y find usan en particular caracteres cita.

Los apóstrofes: '

El shell ignora todos los caracteres especiales escritos entre apóstrofes.

Por ejemplo:

[alumno]> echo variable $HOME y asterix *

variable /home/alumno y asterix banco azul ejemplos arch1 ...
[alumno]> echo 'variable $HOME y asterix *'
variable $HOME y asterix *

Las comillas: “

Como ocurre con los apóstrofes, todos los caracteres especiales entre comillas se
ignoran, exceptuando $, ` (acento abierto) y \. Por ejemplo:

[alumno]> echo “variable $HOME y asterix *”

variable /home/aumno y asterix *

Shell Scripts Página 6 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

La barra invertida: \

Todo carácter que sigue a la barra invertida pierde su significado especial:

[alumno]> echo \variable \$HOME y asterix \*

variable $HOME y asterix *

El uso de los caracteres de cita permite manipulas archivos con nombres poco
convencionales. Una vez creados hay que usarlos con mucha prudencia,
especialmente a la hora de borrar:

[alumno]>touch \* “dos palabras”

[alumno]> ls
* dos palabras azul rojo ...
[alumno]> ls *
* dos palabras azul rojo ...
[alumno]> ls '*'
*
[alumno]> ls 'dos palabras'
dos palabras
[alumno]> ls dos \ palabras
dos palabras
[alumno]> rm *
[alumno]> ls
[alumno]>

Por último, estos caracteres cita inhiben el significado de la tecla [Intro] que
caracteriza el fin del comando; por ello se obtiene la presentación del prompt
secundario $PS2 cuando falta una comilla o un apóstrofe de cierre, o bien cuando
se coloca una barra invertida al final de la línea:

[alumno]> echo “gl

> op”
gl
op
[alumno]> ec\
> ho g\
>lo\
>p
glop

ALIAS

Ciertas líneas de comandos pueden alargarse rápidamente sobre todo con el uso
de tuberías y redirecciones, por lo que su uso frecuente puede resultar
desagradable. Pero es posible simplificar el trabajo del usuario definiendo alias de
comandos.

Shell Scripts Página 7 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

Un alias se caracteriza por un nombre que será reemplazado por un comando.

La lista de alias existentes puede consultarse con el comando alias sin

argumentos.

Se llama a un alias como a cualquier otro comando.

La sintaxis de definición de un nuevo alias es: alias nombre='comando'.

El comando unalias permite suprimir un alias: unalias nombre.

Por ejemplo:

[alumno]> alias lw='ls | wc -l'

[alumno]> alias lw
alias lw= 'ls |wc -l'
[alumno]>lw
8
Si un alias tiene el mismo nombre que un comando, se interpreta el alias. Para
forzar la ejecución de un comando y no de un eventual alias, hay que anteceder a
su nombre el carácter \ o emplear el comando command.

Es posible suprimir todos los alias con la opción -a del comando unalias.

EJECUCIÓN DE COMANDOS

Los comandos escritos por los usuarios pueden ser de naturaleza diferente:

− alias;
− comando interno;
− comando externo.

Comandos internos del shell

Se califica como internos los comandos integrados en el shell.

Los comandos internos se componen esencialmente de herramientas que

permiten modificar el entorno del shell: cambio de directorio actual (cd)
definición de variables (set, unset, etc) y de alias (alias, unalias), estructuras de
control (if, for, while, etc), etc.

La lista exhaustiva de comandos internos de la shell Bash es:

., alias, bg, bind, break, builtin, case, cd, command, continue, declare, dirs,
disown, echo, enable, eval, exec, exit, export, fc, fg, for, getopts, hash, help,
history, if, jobs, kill, let, local, logout, popd, pushd, pwd, read, readonly, return,
set, shift, shopt, source, suspend, test, times, trap, type, typeset, ulimit, umask,
unalias, unset, until, wait, while.
Shell Scripts Página 8 de 32
Sistemas Operativos Monousuario y Multiusuario 1º ESI

La página del manual man Bash detalla los comandos internos que se estudian
aquí.

Comandos externos

Los comandos externos agrupan todos los archivos ejecutables presentes en el

sistema de archivos.

El archivo binario o script asociado a un comando debe estar presente en uno de

los directorios listados por la variable de entorno $PATH.

Si el comando externo tiene el mismo nombre que un interno del shell, se

interpretará éste último.

type, whereis

El comando type permite determinar la naturaleza de los comandos pasados

como argumentos.

Cuando un mismo nombre se atribuye a un alias, un comando, un comando

interno y un comando externo, type indica la interpretación que se hará del
comando.

En la misma línea, el comando whereis permite localizar rápidamente un

comando externo y los archivos de ayuda y de fuentes asociados si están
presentes en el sistema:

[alumno]> whereis echo ls cat

SUSTITUCIÓN DE COMANDOS

La sustitución de comandos consiste en recuperar la salida de un comando en la

línea de comandos. Las salidas de comandos pueden utilizarse para la asignación
de una variable o como argumento de otro comando.

La sintaxis básica de una sustitución de comandos utiliza el apóstrofe invertido

([`]+[espacio]).

Por ejemplo:
echo “mi login es `whoami`”

La segunda sintaxis admitida para la sustitución de comandos es $(). La ventaja de

esta sintaxis es poder anidar las sustituciones de comandos.

Por ejemplo:
echo “contenido de mi directorio: $(ls /home/$whoami))”

Shell Scripts Página 9 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

PROGRAMACIÓN DE SHELL SCRIPTS EN LINUX

PASOS A SEGUIR:

• Crear un archivo de texto con un editor (vi, emacs, etc.). Este archivo
contendrá las órdenes que el shell va a ir interpretando y ejecutando.
• Asignar permisos de ejecución al archivo creado, utilizando la orden
chmod.
• Ejecutar el script generado pasándole los parámetros necesarios
./shell_script param1 param2 …

FORMAS DE EJECUTAR UN SCRIPT

bash prog.sh
Consiste en lanzar un nuevo bash con el nombre del script como argumento. De ello
resulta la creación de subproceso bash que termina automáticamente al finalizar la
ejecución de script. Cualquier modificación del entorno solo interviene en el
subshell, no se modifica la shell inicial.

./prog.sh
Esta forma también utiliza una subshell para su ejecución. El resultado de la
ejecución es el mismo que en la sintaxis anterior.

. prog.sh
El comando interno del shell . (punto, similar al comando interno source) indica al
bash actual que interprete las instrucciones contenidas en el archivo pasado como
argumento. En este caso el entorno Shell de conexión se modifica según el código
del script que ejecuta.

exec ./prog.sh
En este caso es el Shell actual el que ejecuta las instrucciones contenidas en el
archivo.

RECOMENDACIONES:

• Para imponer un intérprete y no otro, existe un comentario especial que hay

que colocar en la 1ª línea del script (#! Ruta del intérprete utilizado). La
primera línea de cada script debe contener:
#!/bin/bash
• Una línea de comentarios debe comenzar con el carácter # . Estos
comentarios no se verán en pantalla cuando se ejecute el script.

Shell Scripts Página 10 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

• Para mostrar comentarios que luego veremos por pantalla, se utilizará el

comando echo.

PASO DE PARÁMETROS A UN PROGRAMA DE SHELL

A menudo queremos que nuestros programas de shell reciban parámetros desde

la línea de órdenes para hacerlos más versátiles. Estos parámetros son lo que se
conoce como parámetros de posición. Los parámetros de posición se pueden usar
dentro de un programa de shell como cualquier otra variable de shell; es decir,
para saber su valor utilizaremos el símbolo $. Los parámetros dentro del shell
script son accesibles utilizando las variables:

$0 Representa al parámetro cero o nombre del programa

$1 Representa al parámetro uno
$2 Representa al parámetro dos
…
$9 Representa al parámetro nueve
${10} Representa al parámetro diez
${11} Representa al parámetro once
…

Ejemplo1:
#!/bin/bash
echo El nombre del programa es $0
echo El primer parámetro recibido es $1
echo El segundo parámetro recibido es $2
echo El tercer parámetro recibido es $3
echo El cuarto parámetro recibido es $4

ALGUNAS VARIABLES ESPECIALES DEL SHELL

$# Número de parámetros que han pasado a la shell.

$* Un argumento que contiene todos los parámetros que se han pasado
($1, $2...) menos el $0.
$? Número donde se almacena el código de error del último comando
que se ha ejecutado.
$$ Número de proceso actual (PID)
$! Último número de proceso ejecutado.

Ejemplo2:
#!/bin/bash
echo El nombre del programa es $0
echo El número total de parámetros es $#
echo Todos los parámetros recibidos son $*
echo El primer parámetro recibido es $1
echo El segundo parámetro recibido es $2
echo El tercer parámetro recibido es $3
echo El cuarto parámetro recibido es $4

Shell Scripts Página 11 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

shift

Sintaxis: shift n

Esta orden se utiliza para desplazar los argumentos, de manera que $2 pasa a ser
$1, $3 pasa a ser $2, y así sucesivamente (esto si el desplazamiento n es igual a
1). Es muy utilizada dentro de los bucles.

Ejemplo3:
#!/bin/bash
#Este script se llama ej_shift2

echo El nombre del programa es: $0

echo El número total de parámetros es: $#
echo Todos los parámetros recibidos son: $*
echo El primer parámetro recibido es: $1
echo El segundo parámetro recibido es: $2
echo El tercer parámetro recibido es: $3
echo El cuarto parámetro recibido es: $4
shift 2
echo Ahora el parámetro \$1 vale: $1
echo Ahora el parámetro \$2 vale: $2
echo Ahora el parámetro \$3 vale: $3
echo Ahora el parámetro \$4 vale: $4
echo El número total de parámetros es: $#
echo Todos los parámetros recibidos son: $*

Mostrará el siguiente resultado:

$./ej_shift2 uno dos tres cuatro cinco seis

El nombre del programa es: ./ej_shift2
El número total de parámetros es: 6
Todos los parámetros recibidos son: uno dos tres cuatro cinco seis
El primer parámetro recibido es: uno
El segundo parámetro recibido es: dos
El tercer parámetro recibido es: tres
El cuarto parámetro recibido es: cuatro
Ahora el parámetro \$1 vale: tres
Ahora el parámetro \$2 vale: cuatro
Ahora el parámetro \$3 vale: cinco
Ahora el parámetro \$4 vale: seis
El número total de parámetros es: 4
Todos los parámetros recibidos son: tres cuatro cinco seis

La orden shift desplaza todas las cadenas en * a la izquierda n posiciones y

decrementa # en n. Si a shift no se le indica el valor de n, por defecto tomará el
valor 1. La orden shift no afecta al parámetro de posición 0 o nombre del
programa.

Shell Scripts Página 12 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

read

Sintaxis: read variable (s)

La orden read se usa para leer información escrita en el terminal de forma

interactiva. Si hay más variables en la orden read que palabras escritas, las
variables que sobran por la derecha se asignan a NULL. Si se introducen más
palabras que variables haya, todos los datos que sobran por la derecha se asignan
a la última variable de la lista.

Ejemplo4:

#!/bin/bash
#script ej_read
#La opción –n se emplea para evitar el retorno de carro
echo –n “Introduce una variable: “
read var
echo La variable introducida es: $var

Ejemplo5:
#!/bin/bash
#script ej_read_var que lee varias variables con read
echo –n “Introduce las variables: “
read var1 var2 var3
echo Las variables introducidas son:
echo var1 = $var1
echo var2 = $var2
echo var3 = $var3

Si ejecutamos el Ejemplo5 sólo con dos parámetros podemos observar que la

variable var3 queda sin asignar, puesto que solo hemos introducido dos valores:

$./ej_read_var
Introduce las variables: uno dos
Las variables introducidas son:
var1 = uno
var2 = dos
var3 =
$

A continuación ejecutamos el Ejemplo5 con cuatro parámetros y podemos

observar que a la variable var3 se le asignan todas las variables a partir de la dos.
$./ej_read_var
Introduce las variables: uno dos tres cuatro
Las variables introducidas son:
var1 = uno
var2 = dos
var3 = tres cuatro
$

Shell Scripts Página 13 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

expr

Sintaxis: expr arg1 op arg2 [op arg3 …]

Los argumentos de la order expr se toman como expresiones y deben ir separados

por blancos. La orden expr evalúa sus argumentos y escribe el resultado en la
salida estándar. El uso más común de esta orden es para efectuar operaciones de
aritmética simple y, en menor medida, para manipular cadenas.

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 utilizar varios operadores, las operaciones de suma y resta se

evalúan en último lugar, a no se que vayan entre paréntesis.
• No hay que olvidar que los símbolos *, ( y ) tienen un significado especial para
el shell y deben ser precedidos por el símbolo backslash ( \ ) o encerrados
entre comillas simples.
Ejemplo6:
#!/bin/bash
#script que multiplica dos variables leídas desde teclado
echo “Multiplicación de dos variables”
echo “-------------------------------“
echo –n “Introduce la primera variable:“
read var1
echo –n “Introduce la segunda variable:“
read var2
resultado=`expr $var1 \* $var2`
echo El resultado de la multiplicación es =$resultado

El resultado de ejecutar el programa anterior es el producto de las dos variables

leídas desde el teclado.

Operadores relacionales
Estos operadores se utilizan para comparar dos argumentos. Los argumentos
pueden ser también palabras. Si el resultado de la comparación es cierto, el
resultado es uno (1); si es falso, el resultado es cero (0). Estos operadores se
utilizan mucho para comparar operandos y tomar decisiones en función de los
Shell Scripts Página 14 de 32
Sistemas Operativos Monousuario y Multiusuario 1º ESI

resultados de la comparación. Los distintos tipos de operadores relacionales son:

= ¿Son los argumentos iguales?
!= ¿Son los argumentos distintos?
> ¿Es arg1 mayor que arg2?
>= ¿Es arg1 mayor o igual que arg2?
< ¿Es arg1 menor que arg2?
<= ¿Es arg1 menor o igual que arg2?

Los símbolos > y < tienen significado especial para el shell, por lo que deben ser
entrecomillados.
Ejemplo7:
#!/bin/bash
#El script se llama ejemplo7
#script que determina si dos variables leídas desde teclado son iguales o no
echo “¿Son iguales las variables?”
echo “--------------------------“
echo –n “Introduce la primera variable: “
read var1
echo –n “Introduce la segunda variable: “
read var2
resultado=`expr $var1 = $var2`
echo Resultado=$resultado

El programa anterior devolverá 0 si las dos variables introducidas son distintas y

1 si son iguales. Veamos la ejecución de Ejemplo7:
$./ejemplo7
¿Son iguales las variables?
---------------------------
Introduce la primera variable: dato
Introduce la segunda variable: dato
Resultado=1
$

Si las variables fuesen distintas, el resultado sería:

$./ejemplo7
¿Son iguales las variables?
---------------------------
Introduce la primera variable: 123
Introduce la segunda variable: 45
Resultado=0
$

Operadores lógicos

Estos operadores se utilizan para comparar dos argumentos. Dependiendo de los

valores, el resultado puede ser arg1 (o alguna parte de él), arg2 o cero.
Como operadores lógicos tenemos los siguientes:

| Or lógico. Si el valor de arg1 es distinto de cero, el resultado es arg1;

si no es así, el resultado es arg2.
Shell Scripts Página 15 de 32
Sistemas Operativos Monousuario y Multiusuario 1º ESI

& And lógico. Si arg1 y arg2 son distintos de cero, el resultado es arg1;
si no es así, el resultado es arg2.
: El arg2 es el patrón buscado en arg1. Si el patrón arg2 está encerrado
dentro de paréntesis \( \), el resultado es la parte de arg1 que
coincide con arg2. Si no es así, el resultado es simplemente el número
de caracteres que coinciden.

No debemos olvidar que los símbolos | y & deben ser entrecomillados o

precedidos del símbolo \, por tener un significado especial para el shell.

Ejemplo8: En este ejemplo incrementamos en una unidad el valor de la variable a.

$a=5
$a=`expr $a + 1 `
$echo $a
6
$
Ejemplo9: En este ejemplo calculamos el número de caracteres de la cadena a.
$a=palabra
$b=`expr $a : “.*”`
$echo $b
7
$
Ejemplo10: En este ejemplo determinamos cuáles son los caracteres comprendidos
entre la a y la z minúsculas en la cadena a.
$a=Febrero_1998
$b=`expr $a : ‘\([a-z]*\)’`
$echo $b
ebrero
$

Otros ejemplos:
expr 4 + 5 devuelve 9
expr 3\* 4 + 6 \/ 2 devuelve 15
expr 3 \* \( 4 + 3 \) \/2 devuelve 10
echo `expr 6 \< 10` devuelve 1, cierto
echo `expr 6 \> 10` devuelve 0, falso
echo `expr abc \< abd` devuelve 1, cierto

Shell Scripts Página 16 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

let

El comando let está integrado en el Bash y permite, como el anterior, efectuar

operaciones aritméticas.
Las ventajas de este comando respecto al anterior son:
- Es más rápido por que está integrado en el Shell y no requiere la creación de
un subproceso.
- Los operadores utilizados son los que se emplean habitualmente en
matemáticas y en otros lenguajes de programación.
- No es necesario insertar un espacio entre cada elemento en una expresión
ni preceder con una barra invertida ciertos operadores como *, < y >.
- La manipulación de variables se simplifica por que es posible asignar una
variable dentro de una expresión, y los nombres de las variables no van
precedidos de un $.
- Existe un mayor nº de operadores para el cálculo aritmético.

Como para el comando test, let puede llamarse de dos maneras: let expresión o
((expresión)). Además, es posible especificar varias expresiones por una coma en
una misma llamada al comando.

Operadores aritméticos
+ suma
- resta
* multiplicación
/ división entera
% resto de la división entera o módulo
** potencia
= asignación

Ejemplos:
let var=2+3
echo $var
Shell Scripts Página 17 de 32
Sistemas Operativos Monousuario y Multiusuario 1º ESI

(( var = 2** 3 ))
echo $var
8

echo $((9/4))
2

Operadores lógicos
&& y lógico
|| o lógico
! negación lógica
< estrictamente menor
<= menor o igual
> estrictamente mayor
>= mayor o igual
== igual
!= diferente
Var++, var--, ++var, --var postincremento, postdecremento,
preincremento y predecremento.

Este ejemplo muestra el postincremento de la variable $i; la comparación >

se evalúa antes del incremento de la variable.

[alumno]> (( i=0 ))
[alumno]> (( i++ >2 )); echo “código de retorno: $? – variable i: $i”
Código de retorno: 1 – variable i: 1
[alumno]> (( i++ > 2 )); echo código de retorno $? – variable i: $i”
Código de retorno: 1 – variable i: 2
[alumno]> (( i++ > 2 )); echo código de retorno $? – variable i: $i”
Código de retorno: 1 – variable i: 3
[alumno]> (( i++ > 2 )); echo código de retorno $? – variable i: $i”
Shell Scripts Página 18 de 32
Sistemas Operativos Monousuario y Multiusuario 1º ESI

Código de retorno: 0 – variable i: 4

test (evaluación de archivos)

Sintaxis: test –opcion archivo

[ expresión ]

La orden test se usa para evaluar expresiones y genera un valor de retorno; este
valor no se escribe en la salida estándar, pero asigna 0 al código de retorno si la
expresión se evalúa como true, y le asigna 1 si la expresión se evalúa como false.
Cuando se invoque la orden test mediante la segunda sintaxis, hay que dejar un
espacio en blanco entre los corchetes.
La orden test puede evaluar tres tipos de elementos: archivos, cadenas y números.

Opciones:
-f Devuelve verdadero (0) si el archivo existe y es un archivo regular (no
es un directorio ni un archivo de dispositivo).
-s Devuelve verdadero (0) si el archivo existe y tiene un tamaño mayor
que cero.
-r Devuelve verdadero (0) si el archivo existe y tiene un permiso de
lectura.
-w Devuelve verdadero (0) si el archivo existe y tiene un permiso de
escritura.
-x Devuelve verdadero (0) si el archivo existe y tiene un permiso de
ejecución.
-d Devuelve verdadero (0) si el archivo existe y es un directorio.

Ejemplo11:
$test –f archivo32
$echo $?
1 (El archivo archivo32 no existe)
$
$ test –f /etc/passwd
$echo $?
0 (El archivo /etc/passwd sí existe)
$

Shell Scripts Página 19 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

test (evaluación de cadenas)

Sintaxis: [ cadena1 = cadena2 ]

[ cadena1 != cadena2 ]
Ejemplo12:
$a=palabra1
$[ “$a” = “palabra2” ]
$ echo $?
1
$[ “$a” = “palabra1” ]
$ echo $?
0
$

De esta manera, test evalúa si las cadenas son iguales o distintas.

test (evaluaciones numéricas)

Sintaxis: número relación número

En evaluaciones numéricas, esta orden es sólo válida con números enteros. Los
operadores usados para comparar números son diferentes de los usados para
comparar cadenas. Estos operadores son:
-lt Menor que
-le Menor o igual que
-gt Mayor que
-ge Mayor o igual que
-eq Igual a
-ne No igual a
Hay unos cuantos operadores que son válidos en una expresión de la orden test a
la hora de evaluar tanto archivos como cadenas o números. Estos operadores son
llamados conectores y son:
-o OR
-a AND
! NOT

Shell Scripts Página 20 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

Ejecución condicional

Para ejecutar el comando cmd2 sólo si el comando cmd1 ha tenido éxito se

separan con &&.
Por ejemplo:
Pwd && ls /home/alumno

Al contrario, para ejecutar el comando cmd2 sólo si el comando cmd1 termina

anormalmente, se separan con ||.
Por ejemplo:
ls /home/invitado || pwd

ESTRUCTURAS CONDICIONALES
Las estructuras de control permiten ejecutar uno o más comandos según el
resultado de una expresión.

La expresión proporcionada como condición de la estructura puede ser cualquier

comando; el código de retorno de este comando es determinante. Se usan
principalmente los comandos test o let como condiciones.

La instrucción if

La instrucción if ejecuta una serie de comandos si la condición indicada es

verdad.

La sintaxis general es:

if condición
then
serie de comandos si condición verdaderos
else
serie de comandos si condición falsa
fi

Cada palabra clave de la estructura (if, then, else y fi) debe encontrarse en una
línea distinta pero la cláusula “else” no es obligatoria.

Ejemplo:

#!/bin/bash
Shell Scripts Página 21 de 32
Sistemas Operativos Monousuario y Multiusuario 1º ESI

if [ “$1” = “glop” ]
then
echo “está bien”
else
echo “no está bien”
fi

Ejecución del script:

[alumno]> ./prog.sh glop

está bien
[alumno]> ./prog.sh pasglop
no está bien

La instrucción for

El bucle for ejecuta la misma serie de comandos tantas veces como valores haya
en una lista dada; en cada iteración, una variable contiene el valor considerado en
esta lista.

Su sintaxis es:

for variable in lista de valores

do
serie de comandos
done

Ejemplo:

#!/bin/bash
for var in a b c d 1 5 4
do
echo “\$var=$var”
done
echo fin

Ejecución del script:

[alumno]> ./prog.sh
$var=a
$var=b
$var=c
$var=d
$var=1
$var=5
$var=4
fin

Shell Scripts Página 22 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

La instrucción while

La instrucción while ejecuta la serie de comandos mientras la condición es

verdad.

while condición
do
serie de comandos
done

Ejemplo:

#!/bin/bash
((i=0))
while (( i++ < 10 ))
do
echo “\$i=$i”
done
echo fin

Ejecución del script:

[alumno]> ./prog.sh
$i=1
$i=2
$i=3
$i=4
$i=5
$i=6
$i=7
$i=8
$i=9
$i=10
fin

Shell Scripts Página 23 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

La instrucción case

Evalúa el valor de una variable y ejecuta varias instrucciones en función de su

valor.

case $variable in
valor1) accion1;;
valor2) accion2;;
………………….
valorn) accionn;;
*) instrucción nnn;….;;
esac

Es equivalente a usar if anidados, aunque más completo y organizado. Si la

variable no es igual a ninguno de los valores especificados, se ejecutan las
instrucciones especificadas tras *).

Ejemplo:

#!/bin/bash
echo “1.- Visualizar nombre de usuario”
echo “2.- Visualizar directorio de trabajo”
echo “Introducir la opción deseada \c”; read opción
case opción in
1) echo “el nombre de usuario es $LOGNAME”;;
2) echo “el directorio de trabajo es $HOME”;;
*) echo “no has tecleado ni 1 ni 2”;;
esac

La instrucción until

Similar a while, las acciones se ejecutan hasta que se cumpla la condición.

Sintaxis:

until condición
do
serie de acciones
done

La instrucción continue

Provoca un salto al comienzo del bucle para continuar con la siguiente iteración.
Vuelve a ejecutar las órdenes que forman la condición del bucle. Si viene seguido
de un nº n, saldrá de n niveles. Se puede usar en cualquiera de los bucles que
hemos visto (while, until y for).

Shell Scripts Página 24 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

La instrucción break

Termina la ejecución del bucle más interno. Si viene seguido de un nº n, saldrá de

n niveles. Se puede usar en cualquiera de los bucles que hemos visto (while, until
y for).

La instrucción exit

Este comando se utiliza para termina inmediatamente un script y volver al Shell

original.

Por ejemplo “exit 6” termina el script devolviendo el nº indicado, lo que puede

usarse para determinar condiciones de error.

“exit 0” termina el script devolviendo 0, para indicar la finalización exitosa de

tareas. Escribir solo “exit” también devuelve el código 0.

EJEMPLOS

#!/bin/bash
#misdatos.sh
#muestra datos relativos al usuario que lo invoca
echo “MIS DATOS.”
echo “Nombre: “$LOGNAME
echo “Directorio: “ $HOME
echo –n “Fecha: “
date
#fin de misdatos.sh

#!/bin/bash
#ciertofalso.sh: escribe cierto o falso según parámetro numérico
if [ $1 = “0” ]
then
echo “Cierto. El parámetro es 0”
else
echo “Falso. El parámetro no es 0”
fi

Shell Scripts Página 25 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

#!/bin/bash
#nvoarch.sh: recibe un nombre y crea un archivo con ese nombre.
#si ya existe emite un mensaje
if [ -f $1 ]
then
echo El archivo ya existe
else
touch $1
echo El archivo $1 fue creado
fi

#!/bin/bash
#rwsi.sh: Indica si un archivo tiene permiso de lectura / escritura
ARCH=$1
if [ -r $ARCH –a –w $ARCH ] # -a similar a AND y –o similar a OR
then
echo El archivo $ARCH se puede leer y escribir
else
echo Al archivo $ARCH le falta algún permiso
fi
ls –l $ARCH

#!/bin/bash
#yo.sh: Captura datos del usuario
clear
echo “Datos del usuario.”
echo –n “Nombre y Apellido: ”; read NOMBRE
echo –n “DNI: “; read DNI
echo
echo “Ha ingresado los siguientes datos: “
echo “Nombre y Apellido: $NOMBRE”
echo “Dni: $DNI”
echo –n “¿es correcto? (sN): “; read RESP
if [ “$RESP” = “s” –o “$RESP” = “S” ]
then
echo “Fin de ingreso.”
else
echo “Debe ingresar sus datos nuevamente”
fi

Shell Scripts Página 26 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

#!/bin/bash
#ecopars.sh: Muestra los parámetros recibidos
echo Cantidad de parámetros: $#
for VAR in $*
do
echo $VAR
done

#!/bin/bash
#mostrar.sh: Se invoca con 3 parámetros y los muestra
echo Nombre del programa: $0
echo Parámetros recibidos:
echo $1; echo $2; echo $3
echo

#!/bin/bash
#trabajo.sh. Dice si se trabaja según el día de la semana
#Invocar con parámetros: domingo, feria, u otro nombre cualquiera
if [ $1 = “domingo” ]
then
echo “no se trabaja”
elif [ $1 = “feriado” ]
then
echo “en algunos se trabaja”
else
echo “se trabaja”
fi

#!/bin/bash
#listapal.sh: Lista de palabras. Muestra palabras de una lista interna
LISTA=”silla mesa banco cuadro armario”
for I in $LISTA
do
echo $I
done
#fin de listapal.sh

Shell Scripts Página 27 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

#!/bin/bash
#contarch.sh: muestra nombres y cuanta archivos en el directorio actual
CUENTA=0
for ARCH in *
do
echo $ARCH
CUENTA=`expr $CUENTA + 1` #agrega 1 a CUENTA
done
echo Hay $CUENTA archivos en el directorio `pwd`
#fin de contarch.sh
#!/bin/bash
#diasemana.sh: Nombre de los días de la semana. Invocar con el nº del 0 al 6. 0 es domingo.
case $1 in
0) echo Domingo;;
1) echo Lunes;;
2) echo Martes;;
3) echo Miércoles;;
4) echo Jueves;;
5) echo Viernes;;
6) echo Sábado;;
*) Debe indicar un nº del 0 al 6;;
esac

#!/bin/bash
#estacion.sh: Indica la estación del año aproximada según el mes
case $1 in
diciembre | enero | febrero)
echo Invierno;;
marzo | abril | mayo)
echo Primavera;;
junio | julio | agosto)
echo Verano;;
septiembre | octubre | noviembre)
echo Otoño;;
*) echo estación.sh debe invocarse como
echo estacion.sh mes
echo con el nombre del mes en minúscula;;
esac

Shell Scripts Página 28 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

#!/bin/bash
#crear1.sh: Crea archivos arch1…arch9, los lista y luego los borra
VAL=1
while [ $VAL –lt 10 ] #mientras VAL sea menor que 10
do
echo creando archivo$VAL
touch arch$VAL
VAL= `expr $VAL + 1`
done
ls –l arch[0-9]
rm arch[0-9]
#fin crearr1.sh

#!/bin/bash
#crear2.sh: Crea archivos arch1…arch9, los lista y luego los borra
VAL=1
until [ $VAL –eq 10 ] #hasta que VAL sea igual que 10
do
echo creando archivo$VAL
touch arch$VAL
VAL= `expr $VAL + 1`
done
ls –l arch[0-9]
rm arch[0-9]
#fin crearr1.sh

Shell Scripts Página 29 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

#!/bin/bash
#exitar.sh: prueba valores de retorno de exit
#
clear
echo “Pruebas de valores de retorno”
echo “ Invocar con parámetros”
echo “ bien, error1, error2, cualquier cosa o nada”
echo “Verificar valor de retorno con”
echo ‘ echo $?’
echo
VALOR=$1
case $VALOR in
bien)
echo” ->Terminación sin error.”
exit 0;;
error1)
echo “ ->Terminación con error 1.”; exit 1;;
error2)
echo “ ->Terminación con error 2.”; exit 2;;
*)
echo “ ->Terminación con error 3.”
echo “ invocado con parámetro no previsto o sin parámetro.”
exit 3;;
esac

echo “quieres empezar el proceso (S/N) \c”; read respuesta

while [ “$respuesta” = “S” ]
do
echo “1.- Visualizar nombre de usuario”
echo “2.- Visualizar directorio de trabajo”
echo “Introducir la opción deseada \c”;
read opción
case opción in
1) echo “el nombre e usuario es $LOGNAME”;;
2) echo “el directorio de trabajo es $HOME”;;
*) echo “no has introducido ni 1 ni 2”;;
esac
echo “Deseas continuar (S/N) \c”;
read respuesta
done

Shell Scripts Página 30 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

echo “quieres empezar el proceso (S/N) \c”; read respuesta

until [ “$respuesta” = “N” ]
do
echo “1.- Visualizar nombre de usuario”
echo “2.- Visualizar directorio de trabajo”
echo “Introducir la opción deseada \c”;
read opción
case opción in
1) echo “el nombre e usuario es $LOGNAME”;;
2) echo “el directorio de trabajo es $HOME”;;
*) echo “no has introducido ni 1 ni 2”;;
esac
echo “Deseas continuar (S/N) \c”;
read respuesta
done

for numero in 1 2 3 4 5
do
echo “1.- Visualizar nombre de usuario”
echo “2.- Visualizar directorio de trabajo”
echo “Introducir la opción deseada \c”;
read opción
case opción in
1) echo “el nombre e usuario es $LOGNAME”;;
2) echo “el directorio de trabajo es $HOME”;;
*) echo “no has introducido ni 1 ni 2”;;
esac
echo “Deseas continuar (S/N) \c”;
read respuesta
done

Shell Scripts Página 31 de 32

Sistemas Operativos Monousuario y Multiusuario 1º ESI

echo “quieres empezar el proceso (S/N) \c”; read respuesta

while [ “$respuesta” = “S” ]
do
echo “1.- Visualizar nombre de usuario”
echo “2.- Visualizar directorio de trabajo”
echo “Introducir la opción deseada \c”;
read opción
case opción in
1) echo “el nombre e usuario es $LOGNAME”; break;;
2) echo “el directorio de trabajo es $HOME”;;
*) echo “no has introducido ni 1 ni 2”;;
esac
echo “Deseas continuar (S/N) \c”;
read respuesta
done

Shell Scripts Página 32 de 32