Uso y programación del Shell

Uso y programación del Shell
El shell es el software que atiende e interpreta las órdenes tecleadas por el usuario desde el terminal y las
traduce a instrucciones en la sintaxis interna del sistema.
Es por tanto, el intérprete de comandos necesario para establecer la interfaz de usuario del sistema. La función
del shell es establecer la interfaz entre el núcleo del sistema y el mundo exterior. Es por tanto, el programa
más importante para los usuarios de Unix.
Es conocido que en Unix existen o pueden existir varios shells. Nosotros vamos a estudiar a fondo el Bourne
shell o estándar.
El Bourne shell es una interfaz de Usuario conversacional, el intérprete o procesador de comandos está activo,
cuando aparece el prompt o indicador correspondiente:
$ _ Este prompt indica que el sistema está preparado para aceptar una entrada del operador bajo la sintaxis de
la línea de órdenes.
Cada línea de órdenes, en general, debe incluir y en este orden :
• El nombre de un comando u orden.
• Las opciones.
• Los nombres de ficheros objetos de la orden.
Cada orden posee una sintaxis propia y lanza un proceso.
Un buen funcionamiento del shell redunda en la ampliación de la capacidad de operación desde el sistema, sin
tener que recurrir lenguajes de programación como el C, para realizar trabajos que pueden solucionarse
fácilmente con la programación del shell.
Metacaracteres.
Los metacaracteres son caracteres o cadenas que tienen un significado especial para el shell, son elementos
del propio shell.
Metacarácter
>
>>
<
<<carácter
|
2>
*
?
[cadena]
Significado
Redireccionamiento de la salida estándar a un
fichero.
Redirección de la salida añadiendo a un fichero
Redirección de la entrada estándar desde un fichero.
Asume entrada por teclado hasta que se introduzca
el carácter especificado.
Inteconexión, tubo o pipeline. La salida de la
primera orden, es la entrada de la segunda.
Redirección de la salida de error.
Sustituye cadenas
Sustituye un carácter
Sustituye caracteres de cadena. Bien en intervalo,
Ejemplo
ls > fichero
ls >> fichero
mail pepe < fichero
cat << f > fichero
cat fichero |more
ls /noexiste 2> fichero
ls a*
ls ejemplo?
rm ejemplo[1−4]
1
bien por un conjunto de caracteres concreto.
rm ejemplo[1234]
;
Ejecución secuencial de órdenes
rm ejem[1−4]plo
who;ls
ls −R / >fichero &
&
Ejecución paralela o desatendida (background)
\
`−−−`
` −−− `
−−−
$0 $1 .
var=valor
$cadena
#cadena
a && b
a||b
Anula interpretación de un carácter especial
Ejecuta órdenes incluidas de shell. Acentos
Toma literalmente lo que hay entre las comillas
simples
Igual que el anterior pero con la diferencia de que
los siguientes caracteres son interpretados: $ \ ` `
Valor de los argumentos de orden
Asignación de valor a variable var .
Valor de la variable cadena
Línea de comentario
Si orden a entonces orden b
Si no orden a entonces orden b
ls −R / fic 2>ferror &
ls \> fichero
echo Directorio:`ls`
echo `Directorio:`ls` `
echo −e Directorio de `pwd` \n `ls`
ls $1
var=hola
echo $var
#comentario
ls /noexiste && ls /
ls /noexiste | | ls /
Ejemplos del uso de Metacaracteres
echo "Hola" > p Redirecciona la salida por pantalla al fichero p. Si hacemos cat p veremos el contenido del
fichero.
cat p > pp Copia el contenido del fichero p en el fichero pp.
cat p pp > ppp Concatena los fichero p y pp en ppp.
cat ppp > lp Escribe el fichero ppp por impresora.
cat < p > pp Toma por entrada lo que hay en el fichero p, y lo da como salida en pp
cat p » pp Añade al final del fichero pp el contenido del fichero p.
| Interconexión (pipelines).Hace que la salida de la primera orden pase a ser la entrada de la siguiente.
ls −l | more Realiza el listado del directorio actual, haciendo paradas al final de cada pantalla
cat p | wc −w Cuenta el nº de palabras que tiene el contenido del fichero p.
wc −c cuenta el nº de caracteres.
wc −l cuenta el nº de líneas.
cat <<1 >ppp Toma como fichero de entrada lo que se escriba por teclado, hasta que pulsemos el carácter 1 al
principio de una linea. Todo lo que tecleemos lo guardará en el fichero ppp.
Escribiremos:
2
>Hola pepe
>Nos vemos a las 10
>1(Fin de la entrada)
Si realizamos la orden cat ppp veremos que contiene dos lineas, que son:
Hola pepe
Nos vemos a las 10
* , ? Son comodines, igual que en el sistema MS−DOS.
ls in* Lista los ficheros que empiecen por in.
ls [ab]* Lista los ficheros que empiecen por la letra a ó b.
ls [a−fl* Lista los ficheros que empiecen por la letra a,b,c,d,e ó f.
ls [ia][nh]* Lista todos los ficheros cuyo primer carácter sea una i ó una a, y el segundo carácter sea una n ó
h, es decir, que empiecen por in ó ah.
; Separa varias ordenes en una misma línea.
ls ; cat p Ejecuta primero la orden ls y después la orden cat p.
& Ejecuta la orden en background (batch), liberando el teclado.
ls −R / >ppp & Lista todos los ficheros desde la raíz hacia abajo, en modo background, redirecciona la salida
al fichero ppp y libera el teclado.
ls −R / >ppp 2>errores & Lista todos los ficheros desde la raíz hacia abajo, en modo background,
redirecciona la salida al fichero ppp, redirecciona la salida de errores al fichero errores, y libera el teclado.
`.....` Ejecución de ordenes entre comillas inversas.
Redireccionamiento.
Un proceso Unix dispone de una entrada estándar y dos salidas estándares (una normal y otra de errores).
Todos los programas tienen estos tres ficheros estándares, creados cuando empiezan a ejecutarse (pasan a ser
procesos) y numerados con enteros pequeños, llamados descriptores de ficheros estándar, y son :
0 Entrada estándar (teclado del terminal)
1 Salida estándar (pantalla del terminal)
2 Salida de error estándar (pantalla del terminal)
Como es conocido cada uno de los ficheros de entrada y salida estándar, pueden ser redireccionados e
interconexionados. Incluso la salida de error, en lugar de a la pantalla del terminal enviarla a un fichero,
3
mediante la siguiente construcción:
ls /noexiste 2>ferror (no hay espacio entre el 2 y el >)
Al no encontrar el directorio especificado, se generará un mensaje de error que se visualizaría por la pantalla
mediante la salida estándar de error (2). Redireccionando esta salida hacia el fichero ferror obtendremos un
fichero de errores.
Existe un dispositivo que se llama /dev/null al que se pueden redireccionar todo aquello que no interesa
registrar ni siquiera por pantalla. Este es un dispositivo nulo o nada.
Ejemplos:
ls /noexiste 2>&1 Redireccionamos la salida de error a pantalla.
ls /noexiste 2>ferror 1>&2 Redireccionamos la salida normal a error.
ls 1>fichero actua igual que ls fichero
ls −R /home 2>/dev/null Los directorios con acceso libre aparecerán por pantalla y los otros no. Probar
también sin este redireccionamiento.
Variables de entorno.
Las variables de unix no se declaran previamente, sino que se crean al utilizarlas. Conviene ponerlas en
mayúsculas.
Existen dos tipos de variables:
• Del entorno o Estándar.
• De usuario.
Las variables de entorno son variables del shell, que sirven para configurar el entorno de trabajo de un
usuario.
El shell, como los lenguajes de programación, tienen variables que también reciben el nombre de parámetros.
Los nombres de las variables suelen ir en mayúsculas.
Las variables de entorno típicas son:
Variable
PATH
LOGNAME
HOME
MAIL
TERM
PS1
PS2
Descripción
Lista de directorios donde buscar órdenes
Nombre del usuario
Nombre del directorio del usuario.(/home/usuari)
Directorio donde se almacena el correo.(/var/spool/mail/usuari)
Nombre del tipo de terminal utilizado.(linux)
Prompt del shell.($)
Prompt del subshell de introducción de órdenes.(>)
Las variables del shell y las de entorno pueden crearse y modificarse, mediante la operación de asignación y
conocer su contenido mediante la de lectura del valor.
4
La asignación de datos a las variables se hace con la orden:
NOMBRE=valor
Cumpliendo una serie de normas que a continuación se detallan:
• `valor' si contiene caracteres blancos debe ir entre comillas dobles ().
• No debe haber caracteres blancos a los lados del signo =.
• El carácter $ no puede pertenecer a `valor'.
Ejemplos:
saludo=hola como estás
saluda=hola
diractual=Directorio actual : `pwd`
La lectura de una variable se realiza con el signo $ precediendo a la variable: $NOMBRE . La única norma
destacable en una lectura de variable es la de que si después de la misma no hay un carácter blanco el nombre
debe figurar entre llaves {}, de la forma ${NOMBRE}.
Ejemplos:
echo $saludo
echo $diractual
echo −−−−−−−−−−$saluda−−−−−−−−
Las variables pueden ser concatenadas para ello solamente hay que cumplir la norma de no dejar caracteres
blancos de separación. Si se concatena una cadena y una variable poner {}.
FINAL=
CADENA=Unix es rápido $FINAL
echo $CADENA
Unix es rápido
FINAL=y eficiente
echo $CADENA
Unix es rápido
ANIMAL=vaca
DESCANSO=${ANIMAL}ciones
echo $DESCANSO
5
vacaciones
ANIMAL=vaca
DESCANSO=$ANIMALciones
echo $DESCANSO
Ejemplos:
Este ejemplo seria erroneo.
El entorno de trabajo de un usuario viene configurado por las variables de entorno. Estas pueden configurarse
con env.
Las variables de entorno se definen en el fichero .profile para de esta forma configurar el entorno de trabajo
desde el momento del acceso al sistema y deben ser exportadas, mediante la orden export, para que puedan
ser accesibles por otros subshells.
Las variables del shell, las de entorno y las que no lo son, pueden visualizarse mediante la orden set.
Ejemplos
echo "Este directorio contiene ls −l No ejecuta bien la orden.
echo "Este directorio contiene `ls −l` Ejecuta la orden.
echo Puedes ver un directorio con $HOME
echo "Puedes ver un directorio con $HOME"
echo "Mi directorio es $HOME"
Dentro de las comillas funciona el $, las comillas simples ` ` y la \ de anulación de la interpretación del
carácter siguiente.
Creación de nuevas órdenes.
Se pueden crear nuevas órdenes definiendo, en el contenido de un fichero, la secuencia conocida que debe
realizar esta nueva orden.
El fichero en el que se definen las órdenes que deben ejecutarse secuencialmente (por lotes) se denomina
shell−script o simplemente script.
Por ejemplo, se desea obtener el contenido del directorio actual mediante la orden dir. Para ello se deberá
crear un fichero de texto con este nombre con el siguiente contenido:
clear
echo −e Directorio actual: `pwd` \n
ls −l |more
6
Para ejecutar este fichero, es decir, para ejecutar secuencialmente el conjunto de órdenes que lo forman,
existen dos posibilidades:
• Ejecutar el shell con la entrada que provenga del fichero dir y no del terminal, es decir del shell o
subshell. Mediante la orden:
sh <dir ó bien sh dir
• Habilitar el permiso de ejecución del fichero correspondiente y ejecutarlo como cualquier orden, de la
siguiente forma:
chmod +x dir
dir
Esta última modalidad tiene una pequeña peculiaridad y es que para que lo anterior se lleve a cabo el
directorio dónde esté situado el fichero dir debe de estar incluido en la variable PATH.
PATH=$PATH:/home/nombre/bin
Observaciones: ver cat /etc/bashrc y cat /etc/profile
Argumentos de las órdenes.
Las órdenes pueden tener argumentos o parámetros posicionales en línea de orden.
Para operar los argumentos de las órdenes basta con operar las variables del shell que toman los valores de los
argumentos.
Veamos a continuación la correspondencia entre los argumentos y las variables que los representan mas tarde
en un script. Tenemos la siguiente orden con estos argumentos :
$ orden argu1 argu2 argu3 arguN
Las variables que toman los valores de los argumentos, respectivamente, son:
Nombre de las variables: $0 $1 $2 $3 . $N
Valores de los argumentos: orden argu1 argu2 argu3 . arguN
El shell proporciona otra variable que muestra los valores de todos los argumento a partir de $1, esta es $*.
Al igual que la anterior tenemos otra variable que proporciona el número de argumentos en línea de órdenes, y
es $#.También tenemos que $$ contiene el PID del proceso en ejecución y $! Contiene el PPID del proceso en
ejecución (PID del proceso padre).
Ejemplos:
cat >prueba
Chmod u+x prueba
clear
PATH=$PATH:/home/usuario
7
echo $1
Para la ejecución:
ls −l $1|more
Joe dir2
$prueba /home
Clear
echo Listado del directorio
sleep 1
if $1;
sh dir2 /home
then
sh dir2
echo El directorio actual es `pwd`;
else
echo El directorio actual es $1;
fi
ls −l $1 |more
Salida de programas como Argumentos.
Es posible ejecutar una orden cuyo argumento sea la salida de otra orden. La forma general será:
orden1 `orden 2`
Ejemplo
echo La fecha es : `date`
echo El directorio actual es: `pwd`
Otra cuestión a tener en cuenta es el valor de retorno de las órdenes. Las órdenes devuelven un código de
retorno numérico e invisible al shell. Este valor es 0 si la orden se ejecutó satisfactoriamente y se interpreta
como verdadero. Y si la orden se ejecutó insatisfactoriamente devuelve un valor distinto de 0 y se interpreta
como falso.(conviene recordar que es al contrario del Lenguaje C que 0 se interpreta como false y 1 como
true).
Por último indicar que el valor de retorno de la última variable está contenida en la variable $?. Y en concreto
mediante la orden:
echo $?.
Uso de variables.
Una variable se caracteriza por poseer un nombre simbólico, un valor o contenido y un tipo determinado.
8
El intérprete shell admite cualquier nombre simbólico que se desee utilizar, siempre que no coincida con el
nombre de una palabra reservada (órdenes, metacaracteres, estructuras de control, variables de entorno, etc.)
El intérprete de shell no distingue entre variables numéricas y alfanuméricas, a cualquier variable se le puede
dar cualquier valor. De forma que, una variable puede ser utilizada en cualquier lugar donde sea posible
utilizar el valor que contiene.
La asignación de un valor a una variable se realiza mediante :
nombre=valor
(si valor es alfanumérico y tiene espacios en blanco debe entrecomillarse).
La sustitución (obtención del valor) de una variable se realiza:
$nombre
Aunque existen las siguientes sustituciones condicionales según la variable nombre tenga o no valor, o esté o
no definida. A continuación vamos a relacionar todas las posibles sustituciones condicionales y el resultado
que provoca. Para poder ver el resultado es necesario utilizar la orden echo:
${nombre:−val} La variable se sustituye por su valor o por val si está vacía o no definida. Es decir no se
asigna el valor a variable.
${nombre:=val} Igual que la anterior, además se asigna val a nombre si está vacía.
${nombre:?mensaje} La variable se sustituye por su valor o emite el mensaje por la pantalla y se detiene la
ejecución si está vacía.
${nombre:+val} La variable se sustituye por val si tiene valor o por nada si está vacía.
Argumentos en línea de orden.
Existen determinadas variables de entorno, como se pudo comprobar en el punto tratado anteriormente,
relacionadas con la obtención de los parámetros pasados al proceso que se ejecuta, vamos a recordar cuales
son:
$0,$1,..,$9 Valor de cada argumento en línea de orden.
$* Valor de todos los argumentos.
$# Valor del número de argumentos.
$? Valor de retorno del último mandato: cero si se ha ejecutado bien y se interpreta como verdadero. Distinto
de cero si se ha ejecutado mal y se interpreta como falso. Al contrario que el Lenguaje C.
Control de flujo.
En cualquier lenguaje, las estructuras de control permiten al programador, controlar el flujo de ejecución para
establecer las condiciones lógicas necesarias, tendentes a la resolución de un problema determinado.
La programación shell dispone de las siguientes estructuras de control:
9
Selección simple:
Se admiten dos formas sintácticas según se separen los elementos de la selección mediante el carácter ; ó el de
nueva línea.
Sintaxis Forma 1:
if expresión ; then . ; [else .;] fi
Sintaxis Forma 2:
if expresión
then
..
[else
.]
fi
Donde expresión puede ser el valor de una variable o el valor de retorno de una orden. Recuérdese que la
mayoría de las órdenes devuelven un valor numérico de retorno después de su ejecución.
Si expresión se resuelve con valor cero (true) se ejecutarán las órdenes de la parte del then y hasta el else, en
caso que expresión se evalúe distinto de cero (false) se ejecutarán las órdenes de la parte del else y hasta el fi.
Selección por casos o sentencia condicional múltiple:
Sintaxis:
case $VAR in
valor1) ;;
valor2|valor3) ;;
valorN) ;;
*) ;;
esac
Se ejecutan las órdenes entre el carácter ) y la cadena ;; del valor correspondiente a la variable VAR. La
salida de la estructura se produce por la ejecución de las órdenes del * , si la variable toma un valor diferente a
todos los indicados.
Es posible indicar varios valores antes de cada paréntesis, separándolas con el carácter | . También se puede
utilizar como patrón los caracteres [ ] indicador de un rango y ? que equivale a cualquier carácter.( con ?
espera un caracter por cada ? que se ponga )
10
Repetición con condición inicial o tipo mientras :
Sintaxis:
while expresión
do
.
done
Se ejecutan las órdenes situadas entre do y done, mientras la expresión sea verdadera (cero). Si la expresión
no es verdadera en un principio, no se llegan a ejecutar ninguna vez las órdenes contenidas en estructura.
Si se especifica como expresión el signo : , se genera un bucle infinito e incondicional.
Ejemplo:
while :
do
echo **********
done
Muestra la cadena especificada infinitas veces. Solamente se puede terminar con ^C.
Estructura de Repetición complementaria a while.:
Sintaxis :
until expresión
do
done
Se ejecutan las órdenes situadas entre do y done, mientras la expresión no sea verdadera (distinto de cero). Si
la expresión es verdadera en un principio, no se llegan a ejecutar ninguna vez las órdenes contenidas en la
Estructura.
Repetición por casos :
Sintaxis:
for VAR in valor1 valor2 . valorN
do
11
.
done
Las órdenes situadas entre do y done se ejecutan tantas veces como valores existan tras la partícula in, de
manera que, la variable VAR irá tomando sucesivamente cada uno de esos valores al principio de cada vuelta
al bucle.
Los valores pueden sustituirse por comodines, u órdenes entre comillas inversas.
Ejemplos:
for f in 1 2 3 4 5
do
more ejer$f.c
done
Muestra todos los ficheros .c que empiecen por ejer y uno de los números especificados.
for fichero in *.c
do
echo $fichero
done
Muestra los nombres de los ficheros con extensión .c
ls *.c >temp
for fichero in `cat temp` ó bien for fichero in `ls *.c`
do
echo $fichero
done
rm temp
Es otra forma de visualizar los nombres de los ficheros .c
El shell permite la utilización de órdenes multilínea en línea de comandos, es decir, una misma orden puede
extenderse en varias líneas. Cuando se pulsa la tecla de ejecución de orden <intro> y la orden no ha
finalizado, aparece automáticamente el valor de la variable PS2, que representa el prompt de segundo nivel
cuyo valor por defecto es el carácter >.
Ejemplo:
12
$ if [ $VARIABLE ]
> then #> prompt de segundo nivel
> echo −e VAR está definida y su valor es $VAR \n
>fi
$
Son útiles si se utilizan órdenes o estructuras de control largas en línea de órdenes.
Comandos
test.
Algunas estructuras de control (if, while, y until) incluyen en su sintaxis una expresión. Esta expresión puede
tomar:
• El valor de una variable
• El valor de retorno de una orden.
• El valor de una expresión condicional.
De manera que, la expresión se evalúa como true si toma valor 0 y como false si toma valor distinto de cero.
test permite evaluar una expresión condicional. De esta forma, es posible establecer las condiciones del
problema.
El efecto que produce es evaluar como falso si el argumento no está definido.
Sintaxis:
test argumento
ó bien la abreviatura
[ argumento ]
En la abreviatura los espacios en blanco antes y después de los corchetes son necesarios.
Argumentos:
El argumento es una expresión condicional de los siguientes tipos:
ARGUMENTO
PARA FICHEROS
−s fic
−f fic
−d fic
−r fic
−w fic
VALOR QUE DEVUELVE
true si existe fic y no está vacío.
true si existe fic y es ordinario
true si existe fic y es directorio
true si existe fic y es de lectura
true si existe fic y es de escritura
13
−x fic
true si existe fic y es de ejecución.
! −argumento fic
Negación de todo lo anterior.
PARA CADENAS (con valor entre comillas dobles)
$A = cadena
true si son iguales
$A != cadena
true si no son iguales
−n cadena
true si no está vacía
−z cadena
true si está vacía
! −n ó −z cadena
Negación de lo anterior.
PARA VALORES NUMERICOS
n1 −eq n2
true si son iguales
n1 −ne n2
true si no son iguales
n1 −gt n2
true si n1 > n2
n1 −ge n2
true si n1 >= n2
n1 −lt n2
true si n1 < n2
n1 −le n2
true si n1 <= n2
Las expresiones condicionales anteriores pueden agruparse entre paréntesis y combinarse con los operadores
lógicos −a (AND), −o (OR) y !(NOT) para formar expresiones condicionales compuestas.
Ejemplos:
if [ $HOME ]
then
echo existe
else
echo no existe
fi
Si HOME está definida devuelve true (0), si no false (1).
if [ ! −n $1 ]
then
echo No hay argumentos
fi
Comprobar qué ocurre con y sin comillas.
read
Acepta información desde la entrada estándar.
14
Sintaxis:
read variable
Permite leer datos desde el terminal hasta encontrar un <intro> o un final de fichero, y los almacena en una
variable.
exit
Provoca un salida del programa.
Sintaxis:
exit [número]
Provoca la salida del script al proceso anterior. Tras la orden puede ponerse un valor numérico que será el
valor de retorno del programa.
export
Propagación del entorno.
Sintaxis:
export VAR1 [ VAR2 .. VARn ]
Propaga las variables a los subshells.
readonly
variable de solo lectura.
Sintaxis:
readonly var
No permite alterar el valor de una variable.
break
interrupción del bucle.
Sintaxis:
break
Interrumpe cualquier repetición.
continue
Inicio de repetición.
15
Sintaxis:
continue
Hace comenzar una repetición desde un punto intermedio del bucle.
shift
Desplazamiento de argumentos de shell.
Sintaxis:
shift
Desplaza los argumentos que recibe un programa shell una posición a la izquierda. El argumento 1 desaparece
y el i => i − 1.
Ejemplo:
echo $# $*
shift
echo $# $*
shift (Repetir varias veces shift y echo con varios argumentos)
set y sh
Depuradores de programas shell.
Sintaxis:
set [−/+opciones] (−activa, +desactiva)
sh [−opciones] script
Opciones:
v A medida que va ejecutándose el script este va apareciendo en pantalla.
x Ejecución paso a paso y se visualiza interpretando órdenes.
Las órdenes set deben incluirse en el script a depurar, mientras que sh se ejecuta desde línea de órdenes.
tput
Devolución de secuencias de terminal. Obtiene de terminfo las secuencias de escape asociadas con una acción
sobre el terminal actual. Así, las secuencias de escape quedan determinadas mediante un nombre
independiente definido para cada terminal. Puede ocurrir que determinadas secuencias no se encuentren
definidas para determinados terminales. Se puede ver en /usr/lib/terminfo.
16
Sintaxis:
tput [nombre secuencia terminal]
Pudiendo tomar secuencia cualquiera de los soguientes valores:
SECUENCIA
Clear
Bold
Blink
ri
Ind
Civis
Cvvis
Cup l c
Setb n
Setf n
Sgr0
FUNCIÓN DE LA SECUENCIA DE ESCAPE DEVUELTA
Borrado de la pantalla
Vídeo brillante
Vídeo parpadeante
Scroll hacia abajo
Scroll hacia arriba
Cursor invisible
Cursor visible
Posiciona el cursor en línea l columna c
Fija el color del fondo con el código n
Fija el color de la tinta con el código n
Valores por defecto
Para gestionar la salida por pantalla, también pueden utilizarse las secuencias de los caracteres de barra
invertida, que suelen intervenir fundamentalmente con la orden echo, con su opción −e , y que son:
\b Backspace
\c No avanza un carácter tras escribir en pantalla.
\f Avance de página.
\r Retorno de carro.
\n Avance de línea más retorno de carro.
\t Tabulador horizontal.
\\ Escribe por pantalla el carácter \, ya que este carácter inhibe la interpretación del siguiente.
\a Pitido, Beep.
tic
Se pueden añadir nuevas secuencias de escape asociadas a un terminal. Para ello habrá que definirlas y
compilarlas posteriormente con la orden tic:
Sintaxis:
tic [ opciones ] fichero_descripción
La orden tic compila un fichero conteniendo una descripción de terminal en formato fuente y añade el
resultado en terminfo.
17
expr
Imagínese, que a una variable se le asigna un valor numérico, y que después, se le quiere sumar otra cantidad.
Es lógico que se intentara hacer de la siguiente forma :
a=$a+2 ( a es la variable, 2 la cantidad a sumar)
El resultado obtenido es 5+2 y no 7.
Para realizar cálculos numéricos, se utiliza el comando expr.
Sintaxis:
expr expresión
Expresión usa precedencia aritmética normal, no modificable. Necesita que cada elemento esté rodeado por
blancos.
La expresión se construye usando enteros sin tipo y operadores aritméticos normales, estos son: + − /
\*(multiplicación, el * debe ir precedido de \ puesto que este carácter es el símbolo comodín del shell).
Ejemplo:
a=`expr $a + 2`
trap
Cualquier buen programa shell debe tener en cuenta los errores y la recepción de señales que se produzcan en
tiempo de ejecución .
Los errores de las órdenes en tiempo de ejecución es conveniente que se redireccionen a un fichero, o bien,
/dev/null que es un dispositivo nulo de Unix.
Aparte de los errores, deben ser controladas las señales recibidas por el script durante su ejecución.
Una señal puede estar causada por diferentes sucesos en determinados momentos, por ejemplo, un error grave
en el sistema, la pulsación de la tecla de interrupción <del>, etc. Para controlar estas señales, las que son
controlables, desde los programas shell de usuario se dispone de la orden trap.
Sintaxis:
trap orden números_de_señal
Invoca la orden especificada entre comillas dobles, en caso de recepción en el script donde se incluye de una
de las señales indicadas.
Veamos algunas de estas señales:
Nº DE SEÑAL
0
1
2
CAUSA DE LA SEÑAL
Salida del shell (^d u otra razón)
Colgar el teléfono de comunicación. Corte
Interrupción (tecla <del>)
18
3
9, 15
Abandonar (<ctrl> \ , se produce un vaciado de memoria.)
Señales utilizadas en la eliminación de procesos por la orden kill.
Ejemplo:
Realizamos un script cuyo contenido sea:
trap banner mensaje 0
read # Efectuamos una parada con el fin de poder dar la señal especificada.
Al pulsar ^d aparecerá el mensaje enviado por banner.
Funciones.
La programación shell permite el uso de funciones, entendiendo como tal, un grupo de órdenes a las que se les
referencia mediante un nombre que se invoca desde el módulo llamador en el momento de su ejecución y que
puede devolver un valor de retorno.
Las funciones deben estar declaradas antes de ser invocadas por su módulo llamador, que puede ser del mismo
nivel jerárquico. La declaración de funciones se realiza de la siguiente forma:
nombre([parametros] )
{
return [valor_retorno]
}
Donde la orden return provoca la vuelta al módulo llamador y devuelve valor_retorno que se almacena en la
variable $?. La orden return se puede encontrar en cualquier punto de la función. Para invocar esta función
desde otro módulo se hará simplemente poniendo : nombre.
Es posible enviar parámetros por valor que se recogerán mediante las variables ${1}, ${2}, ..${9} no en la
cabecera sino en el cuerpo de la función. La llamada a una función con paso de parámetros se hará :
nombre valor1 valor2 etc si se trata de valores constantes.
nombre $var1 $var2 .etc si se trata de variables.
Las funciones pueden definirse también en línea de comandos como una orden multilínea. Así, quedan
residentes en el shell actual y pueden ser invocadas en cualquier momento desde línea de órdenes.
Ejemplo:
Se define la función antes de ser utilizada.
$ muestra ( )
19
{
echo ${1}
echo ${2}
return 0
}
De esta forma usamos la función:
$ muestra hola adiós.
hola
adios
$ echo $?
Las funciones no son exportables ni están automáticamente disponibles para otros subshells. Se pueden ver
con la orden set.
10
20