Shell Scripts INICIAL

Sistemas Operativos Monousuario y Multiusuario 1º ESI

Shell Scripts Página 1 de 32

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

Sistema Linux usuario



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:



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



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



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



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 *



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.



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.



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



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 …

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.

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.



• 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



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.



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 $



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=èxpr $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



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=èxpr $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.



& 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=èxpr $a + 1 ` $echo $a 6 $

Ejemplo9: En este ejemplo calculamos el número de caracteres de la cadena a. $a=palabra $b=èxpr $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=èxpr $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 èxpr 6 \< 10` devuelve 1, cierto

echo èxpr 6 \> 10` devuelve 0, falso

echo èxpr abc \< abd` devuelve 1, cierto



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



5

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








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



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



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



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


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



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


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



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



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



#!/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



#!/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

#!/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 #contarch.sh: muestra nombres y cuanta archivos en el directorio actual CUENTA=0 for ARCH in * do echo $ARCH CUENTA=èxpr $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



#!/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= èxpr $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= èxpr $VAL + 1` done ls –l arch[0-9] rm arch[0-9] #fin crearr1.sh



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

#!/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 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



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





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”;;


Documents

Shell Scripts INICIAL