Uso y programación del Shell

Sistemas Operativos. Sistema Unix. Shell. Intérprete de comandos. Interfaz de usuario. Núcleo del sistema. Metacaracteres. Significado. Redireccionamiento. Variables de entorno. Órdenes. Control de flujo. Comandos. Sintaxis. Funciones

  • Enviado por: Puria Shahdoost Rad
  • Idioma: castellano
  • País: España España
  • 19 páginas
publicidad

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

Significado

Ejemplo

>

Redireccionamiento de la salida estándar a un fichero.

ls > fichero

>>

Redirección de la salida añadiendo a un fichero

ls >> fichero

<

Redirección de la entrada estándar desde un fichero.

mail pepe < fichero

<<carácter

Asume entrada por teclado hasta que se introduzca el carácter especificado.

cat << f > fichero

|

Inteconexión, tubo o pipeline. La salida de la primera orden, es la entrada de la segunda.

cat fichero |more

2>

Redirección de la salida de error.

ls /noexiste 2> fichero

*

Sustituye cadenas

ls a*

?

Sustituye un carácter

ls ejemplo?

[cadena]

Sustituye caracteres de cadena. Bien en intervalo, bien por un conjunto de caracteres concreto.

rm ejemplo[1-4]

rm ejemplo[1234]

rm ejem[1-4]plo

;

Ejecución secuencial de órdenes

who;ls

&

Ejecución paralela o desatendida (background)

ls -R / >fichero &

ls -R / fic 2>ferror &

\

Anula interpretación de un carácter especial

ls \> fichero

`---`

Ejecuta órdenes incluidas de shell. Acentos

echo “Directorio:`ls`

` --- `

Toma literalmente lo que hay entre las comillas simples

echo `Directorio:`ls` `

“--- “

Igual que el anterior pero con la diferencia de que los siguientes caracteres son interpretados: $ \ ` `

echo -e “Directorio de `pwd` \n `ls`”

$0 $1 ….

Valor de los argumentos de orden

ls $1

var=valor

Asignación de valor a variable var .

var=hola

$cadena

Valor de la variable cadena

echo $var

#cadena

Línea de comentario

#comentario

a && b

Si orden a entonces orden b

ls /noexiste && ls /

a | | b

Si no orden a entonces orden b

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:

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

    Descripción

    PATH

    Lista de directorios donde buscar órdenes

    LOGNAME

    Nombre del usuario

    HOME

    Nombre del directorio del usuario.(/home/usuari)

    MAIL

    Directorio donde se almacena el correo.(/var/spool/mail/usuari)

    TERM

    Nombre del tipo de terminal utilizado.(linux)

    PS1

    Prompt del shell.($)

    PS2

    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.

    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

    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

    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

    clear

    echo $1

    ls -l $1|more

    Chmod u+x prueba

    PATH=$PATH:/home/usuario

    Para la ejecución:

    $prueba /home

    Joe dir2

    Clear

    echo “Listado del directorio”

    sleep 1

    if $1;

    then

    echo “El directorio actual es `pwd`”;

    else

    echo “El directorio actual es $1”;

    fi

    ls -l $1 |more

    sh dir2 /home

    sh dir2

    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.

    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:

    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 )

    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

    ….

    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:

    $ 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

    VALOR QUE DEVUELVE

    PARA FICHEROS

    -s fic

    true si existe fic y no está vacío.

    -f fic

    true si existe fic y es ordinario

    -d fic

    true si existe fic y es directorio

    -r fic

    true si existe fic y es de lectura

    -w fic

    true si existe fic y es de escritura

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

    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.

    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.

    Sintaxis:

    tput [nombre secuencia terminal]

    Pudiendo tomar secuencia cualquiera de los soguientes valores:

    SECUENCIA

    FUNCIÓN DE LA SECUENCIA DE ESCAPE DEVUELTA

    Clear

    Borrado de la pantalla

    Bold

    Vídeo brillante

    Blink

    Vídeo parpadeante

    r i

    Scroll hacia abajo

    Ind

    Scroll hacia arriba

    Civis

    Cursor invisible

    Cvvis

    Cursor visible

    Cup l c

    Posiciona el cursor en línea l columna c

    Setb n

    Fija el color del fondo con el código n

    Setf n

    Fija el color de la tinta con el código n

    Sgr0

    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.

    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

    CAUSA DE LA SEÑAL

    0

    Salida del shell (^d u otra razón)

    1

    Colgar el teléfono de comunicación. Corte

    2

    Interrupción (tecla <del>)

    3

    Abandonar (<ctrl> \ , se produce un vaciado de memoria.)

    9, 15

    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 ( )

    {

    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