Apuntes de shell script

José Navero Esta Documento trata de la programación en

Shell Script desde un nivel básico.

Apuntes de Unix Shell Script.

http://www.namocode.com

http://devthisblog.wordpress.com/

http://www.namocode.com/


http://devthisblog.wordpress

.com/

2

Índice

1. Una pequeña introducción. ................................................................................. 3

2. Que necesitamos para escribir un Shell script. .................................................... 3

3. Ejecutando un Shell Script. ................................................................................. 3

4. Nuestro primer Shell Script. ............................................................................... 3

5. Algunos conceptos básicos. ................................................................................ 3

Sobre comandos: ....................................................................................................... 3

Comentarios: ............................................................................................................. 4

Salida por pantalla: .................................................................................................... 4

6. Variables. ........................................................................................................... 4

El comando Export .................................................................................................... 4

El comando set .......................................................................................................... 4

Variables posicionales y automáticas ......................................................................... 4

Arrays ........................................................................................................................ 5

7. Salida por pantalla y entrecomillado. .................................................................. 5

Caracteres no imprimibles ......................................................................................... 5

Entrecomillar ............................................................................................................. 6

Ejecución de órdenes ................................................................................................. 6

Redireccionamiento ................................................................................................... 6

Segundo plano ........................................................................................................... 7

8. Shell Script, El lenguaje. .................................................................................... 7

Estructuras de control ................................................................................................ 7

La instrucción IF. ................................................................................................... 8

La instrucción CASE. ............................................................................................. 9

Bucles ........................................................................................................................ 9

Bucle WHILE ......................................................................................................... 9

Bucle UNTIL ....................................................................................................... 10

Bucle FOR............................................................................................................ 10

Pequeña reflexión. ................................................................................................... 10

Varios comandos… ................................................................................................. 11

Comando test ........................................................................................................ 11

Comando break .................................................................................................... 11

Comando continue ................................................................................................ 12

Comando sleep ..................................................................................................... 12

Comando expr ...................................................................................................... 12

Anexo I. Ejemplos ...................................................................................................... 13



.com/

3

1. Una pequeña introducción.

Este escrito da por supuesto el conocimiento de los comandos de Unix / Linux. Los

Script de Shell es una forma de realizar tareas repetitivas, ejecución de comandos Unix

y como veremos a continuación la programación en Shell script es muy potente. Para

este manual he utilizado sco Unix y el Shell ksh. Al igual que ksh existen diferentes

shells. Una Shell es un intérprete de comandos en nuestro caso en Unix / Linux. El más

utilizado (por mi parte en Ubuntu es el bash). Como ya he indicado antes este manual lo

he orientado a sco unix y ksh (Korn Shell) aunque sirve para cualquier otro shell.

2. Que necesitamos para escribir un Shell script.

Básicamente, necesitamos un Shell como los descritos anteriormente (obviamente),

tener un Linux instalado, un unix, live cd etc. Y para escribir el script necesitamos un

editor, como el nano, el vim, el vi o lo que más nos guste, el caso es que edite.

3. Ejecutando un Shell Script.

Una vez que tenemos nuestro script escrito, podemos ejecutarlo de diferentes

formas.

Mediante un redireccionamiento de entrada. ejemplo: ksh < fichero

Pasando el fichero como argumento. ejemplo: ksh fichero argumento 1 arg2 ...

Si ponemos ksh -x fichero, hace una traza comprobando que funcione bien

Convertir el fichero en un ejecutable con la orden chmod.

4. Nuestro primer Shell Script.

Para hacer nuestro primer script de Shell, debemos crear un archivo con un editor de

texto (ejemplo vi).

#!/bin/ksh

echo “Hola que tal estas”

¿Qué hace este script?

La primera línea indica el Shell que se va a utilizar en nuestro caso el ksh, la segunda

línea muestra por pantalla la frase “Hola que tal estas”

5. Algunos conceptos básicos.

Sobre comandos:

Es importante destacar que Unix es case sensitive, es decir diferencia mayúsculas y

minúsculas, es decir no es lo mismo echo que Echo



.com/

4

Comentarios:

Si deseamos poner comentarios en nuestro script debemos usar la almohadilla

#Esto es un comentario en un script de Shell.

Salida por pantalla: Como hemos visto en nuestro primer script, es posible mostrar por pantalla textos o

variables con la orden echo.

6. Variables.

Para utilizar una variable basta con hacer una asignación como vemos a

continuación.

variable = “valor”

Esta orden establece un valor en una variable.

Si deseamos mostrar el contenido de una variable utilizaremos la orden

echo $variable

Si deseamos introducir un dato a una variable desde el teclado, utilizamos la orden read

seguido de la variable.

read variable

Si además deseamos introducir un texto antes de leer la variable usamos read de la

siguiente forma:

read variable? “texto”

El comando Export

export imprime en pantalla una lista de variables exportadas. Si deseamos

exportar una variable, utilizamos “export variable” (sin comillas).

El comando set

Este comando “set” Sirve para leer o escribir variables.

Variables posicionales y automáticas

Existen variables que son activadas por el Shell de forma automática, estas

variables tienen gran importancia por su utilidad a la hora de crear nuestros scripts. En la

siguiente tabla veremos dichas variables.



.com/

5

Variable Descripción

$? Variable que indica el código de retorno del script. Retorna 0 si se ha

ejecutado con éxito y distinto de 0 si ha habido un error.

$$ Variable que almacena el pid del procedo de ejecución del script.

$! Variable que contiene el número de identificación del último proceso en

background.

$1, $2 …

$9, ${10}

…

Variables posicionales. Son las variables que le pasamos por línea de

comandos a nuestro script de Shell. Nota, desde la posición 10 en adelante

deben llevar llaves {}

$# Variable que contiene el número total de parámetros que se le pasan al script.

$* Variable que crea una cadena de texto con todas las variables pasadas.

Arrays

Además de las variables normales, posicionales y automáticas, podemos crear

arrays. Dichos arrays se definen de la siguiente forma:

set -A nombre valor1 valor2 ...... valorn

Para mostrar la tercera posición de un array, utilizamos el comando:

echo ${nombre[3]}

Por último si deseamos ver el array completo basta con teclear echo ${nombre[*]}

7. Salida por pantalla y entrecomillado.

Como ya sabemos, la orden echo muestra por pantalla los textos o variables que

deseemos. Podemos darle formato a esta salida, todo depende del entrecomillado y de

los caracteres no imprimibles como vemos a continuación.

Caracteres no imprimibles

Estos caracteres son:

\n Introduce un salto de línea en la frase

\c Continúa en la misma línea.

\e Carácter Escape.

\t Escribe un tabulador.

Ejemplo:

echo “Hola\n Me llamo Juan”

La salida de este comando es la siguiente:

Hola

Me llamo Juan



.com/

6

Entrecomillar

Es muy importante entrecomillar correctamente los textos y las variables ya que

depende del entrecomillado la forma en que vamos a mostrar o utilizar nuestras

variables.

Existen diferentes formas de entrecomillar. Al teclear comillas simples „‟, todo lo

que va entre estas comillas pierde su significado, pasando a ser todo texto.

Sin Embargo, las comillas dobles “” podemos mostrar los valores que contienen las

variables.

Otra forma de entrecomillar es utilizar la barra inversa \ con esta barra podemos

cubrir caracteres no imprimibles. De esta forma podremos mostrar comillas, por

ejemplo.

Además de poder entrecomillar podemos utilizar los paréntesis para poder agrupar

diferentes ordenes.

Ejemplos:

Orden Resultado

echo * Muestra los archivos (funciona igual que cuando ponemos ls)

echo \* Muestra el carácter * por pantalla

variable = 1

echo „Prueba variable‟

Muestra por pantalla prueba variable

variable = 1 echo “variable”

Muestra por pantalla 1

Ejecución de órdenes

Existen varias formas de ejecutar las diferentes órdenes en Shell Script.

Punto y coma: Se utiliza para ejecutar una orden después de otra. orden1;orden2

Or(||): Ejecuta las dos órdenes al mismo tiempo. orden1||orden2

And (&&): Se ejecuta la segunda orden si la primera se ha ejecutado con éxito.

Redireccionamiento

Una vez que ejecutemos una orden, tenemos la posibilidad de enviar el resultado a

un dispositivo diferente de la pantalla. Por ejemplo, podemos enviar el resultado a un

archivo.

Ejemplos:

pwd;date > resul

En este caso, primero ejecuta el comando pwd y posteriormente crea el archivo

resul donde insertará el resultado de ejecutar date.

(pwd;date) > resul

Está orden similar a la anterior la diferencia (los paréntesis) en vez de introducir el

resultado de date insertará el resultado de ejecutar ambas ordenes.

Como podemos ver con el símbolo mayor que realizamos los redireccionamientos.

Si ponemos un único símbolo borra el fichero si existe y lo crea nuevo. Sin embargo al

poner dos mayor que seguidos (>>) El resultado que tenemos es que si el fichero no



.com/

7

existe se crea y si existe, anexa el resultado en el fichero. Por otro lado además de

recoger los resultados, también podemos redireccionar los errores de la siguiente forma:

Pwd > resul 2 > error

En este ejemplo almacenamos en el fichero resul el resultado de ejecutar el

comando y si se produce un error, dicho error se almacena en el fichero error.

Segundo plano

Unix / Linux nos ofrece la posibilidad de ejecutar órdenes y enviarlas a segundo

plano, es decir, mientras se ejecuta una orden podemos seguir ejecutando otras órdenes.

Esto combinado con los paréntesis o creando un Script de Shell nos permite realizar

operaciones muy potentes. Para poder enviar una orden a segundo plano usamos el &.

Ejemplos:

orden1;orden2&

En este ejemplo, se ejecuta la primera orden y después la siguiente orden la ejecuta

en segundo plano.

(orden1;orden2)&

En el segundo ejemplo, las dos órdenes se ejecutarán en segundo plano

Básicamente, para poder trabajar con los comandos en primer y segundo plano se

usan 3 comandos.

Jobs: Muestra los comandos que están en ejecución

Fg: pasa a primer plano un comando

Bg: pasa a segundo plano un comando

Si pulsamos control+z durante la ejecución de una orden, dicha orden se detiene y

podemos pasarla a segundo plano con bg o primer plano con fg. Mientras que con jobs

muestra las ordenes que están en proceso.

8. Shell Script, El lenguaje.

Shell Script tiene la misma funcionalidad que cualquier lenguaje de programación,

además, de la potencia de un lenguaje de programación, podemos utilizar cualquier

comando que pueda usar Linux/Unix, lo que nos da una gran potencia.

Estructuras de control

Son estructuras que permiten ejecutar entre un bloque u otro, en base a una

condición previamente indicada.

Las estructuras posibles en Shell script son las siguientes if y case que veremos a

continuación.



.com/

8

La instrucción IF.

Se encarga de elegir ente dos o más bloques, en el diagrama podemos ver

claramente el funcionamiento de la instrucción.

Se cumple

Bloque 1

Variable IF condición Resto del programa

Bloque 2

No se cumple

La sintaxis de la instrucción IF es la siguiente:

Para un if sencillo:

if <comando> then

Bloque de instrucciones

fi

Para un if con dos bloques

if <comando> then

Bloque de instrucciones 1

else


fi

Y por supuesto podemos anidar varios if, es decir, meter una instrucción if dentro

de otro.

if<comando> then


else

if<comando> then


else


fi

fi



.com/

9

La instrucción CASE.

Esta instrucción es una instrucción similar al if, es decir secuencia de control. El

siguiente diagrama muestra el funcionamiento de esta instrucción.

Si variable

Vale X Bloque 1

Vale Y Bloque 2 Resto del programa

Vale Z Bloque 3

La sintaxis de esta instrucción es la siguiente:

case variable/expresión in

1) Orden1

Orden2

…;;

[2-4]) Orden1

Orden2

….;;

*) Orden1

Orden2

…;

esac

Analizando el comando anterior, podríamos decir, si la variable es igual que uno,

ejecuta el primer bloque. Para salir del bloque se ponen dos puntos y comas seguidos

como se pueden ver.

Si nos fijamos en el segundo bloque, hace referencia a un rango es decir, si la

variable o expresión está dentro del rango ósea puede ser el valor 2, 3 o 4.

Por último el asterisco, indica que si no es ninguna de las opciones anteriores entra su

bloque.

Como en todos los comandos, esac indica el final del comando case.

Bucles

Los bucles, como en cualquier lenguaje de programación sirven para repetir

bloques de comandos.

Bucle WHILE

Realiza un bucle mientras se cumpla una condición determinada.

La sentencia del bucle es la siguiente:



.com/

10

while comando

do

Orden1

Orden2

…

done

Mientras se cumpla repetir.

Bucle UNTIL

Realiza un bucle hasta que se cumpla una condición determinada.


until comando

do

Orden1

Orden2

…

done

Bucle FOR

Realiza una iteración un número determinado de veces,


for variable in valor1 valor2 valorn…

do

Orden1

Orden2

…

done

A continuación se muestra un ejemplo del uso del bucle for.

for a in lunes martes miércoles jueves

do

echo $a

done

Este ejemplo muestra por pantalla la siguiente línea:

Lunes martes miércoles jueves

Pequeña reflexión.

Hasta aquí todo perfecto, pero ahora ¿Qué comandos uso en las evaluaciones?

¿Cómo utilizo todo esto?.



.com/

11

A continuación iré mostrando los comandos más comunes, así como algunos ejemplos

de Shell script.

Varios comandos…

Comando test

Este comando es el comando evaluador más utilizado en los bucles o sentencias

de control. Puede trabajar sobre valores numéricos, ficheros o cadenas de texto.

Uso sobre valores numéricos.

-eq: igual

-ne: distinto

-gt: mayor que

Operadores -lt: menor que

-ge: mayor o igual que

-le: menor o igual que

Este tipo de operadores, solamente admite números enteros positivos y negativos.

Uso sobre ficheros.

-s: comprueba que existe y no está vacio

-e: solo comprueba si existe

-f: comprueba si es un fichero convencional

Operadores -d: comprueba si es un directorio

-w: comprueba si tiene permiso de escritura

-r: comprueba si tiene permiso de lectura

-x: comprueba si tiene permiso de ejecución.

Uso sobre cadenas.

-z: indica si la cadena tiene longitud cero

Operadores -n: Indica si la cadena no tiene longitud cero.

Comando break

Con este comando podemos interrumpir una secuencia de control como puede

ser un bucle, si se produce una acción concreta podemos indicar que deje de ejecutar el

bucle “rompiéndolo” para continuar con la ejecución del script.



.com/

12

Comando continue

Este comando, forzamos a un bucle a que realice otra iteración, sin que acabe de

realizar todos los comandos o evaluadores que sean posteriores.

Comando sleep

Este comando realiza una pausa de uno a varios segundos en función del tiempo

indicado. La sintaxis es la siguiente: sleep 2 (realiza una pausa de 2 segundos).

Comando expr

Este comando realiza una operación básica entre dos variables o más. Un

ejemplo de su uso podría ser este: a= expr $a + 1

Para ver más información sobre algunos script en el Anexo I adjunto varios ejemplos de

script donde se puede ver el uso de los comandos, evaluadores, bucles etc.



.com/

13

Anexo I. Ejemplos

Ejemplo 1. Script “Hola mundo”

#!/bin/sh

echo “Hola Mundo”

Ejemplo 2. Script con una toma de decisiones

#!/bin/sh

clear

echo “Introduzca un numero”

read numero

res= expr $numero % 2

if test res –eq 0 ; then

echo “El numero es par”

else

echo “El numero es impar”

fi

echo “Fin programa”

Ejemplo 3. Este script que reciba un directorio como primer parámetro, y a continuación

una lista de archivos. El script valida que los parámetros recibidos sean realmente

archivos y luego copiarlos al directorio recibido

#!/bin/sh

if test $# -le 1; then

echo “Argumentos no validos”

exit

fi

if test –d $1; then

carpeta=$1

for I in $*;

do

if test –f $i; then

cp $i $carpeta

echo “Archivo $i copiado en $carpeta”

fi

done

else

echo “Argumento no valido”

fi



.com/

14

Ejemplo 4. Este script muestra un menú con los nombres de login de los usuarios

conectados y al elegir uno se nos muestre el nombre completo del mismo así como su la

ruta de su directorio personal.

#!/bin/sh

clear

usuario=''

echo "--------------- MENU USUARIOS -----------------"

echo "-----------------------------------------------"

who -s | cut -f1,2 -d ' ' | cut -f1,1 -d ' '|nl

echo "-----------------------------------------------"

echo

echo "Escribe el nombre de uno de los usuarios logados en el sistema"

echo "para ver su alias y la ruta de su carpeta personal."

echo "Si ves algun usuario repetido es porque estas usando una"

echo "terminal de comandos con ese usuario."

echo

echo -n "Usuario :"

read usuario

if [ -z $usuario ]; then

echo

echo "No se ha introducido ningun dato"

echo

else

nombreu=$(grep ^$usuario /etc/passwd | cut -d ":" -f5 | cut -d "," -f1)

homeu=$(grep ^$usuario /etc/passwd | cut -d ":" -f6 | cut -d "," -f1)

if [ -z $nombreu ]; then

echo

echo "El nombre de usuario indicado no existe"

echo

else

echo "El nombre del usuario indicado es :" $nombreu

echo "El directorio personal es :" $homeu

echo

echo -n "Pusla una tecla para continuar..."

read enterKey

echo

fi

fi

Ejemplo 5. script que muestra un menú con las siguientes opciones:

a. Visualizar atributos del directorio actual.

b. Visualizar directorio actual

c. Mostrar el contenido de un fichero

d. Salir



.com/

15

#!/bin/bash

#Inicio del script.

while :

do

clear

opcion=0

echo "-------------MENU PRINCIPAL--------------------"

echo "-----------------------------------------------"

echo "a. Visualizar atributos del directorio actual"

echo "b. Visualizar directorio actual"

echo "c. Mostrar el contenido de un fichero"

echo "d. Salir"

echo "-----------------------------------------------"

echo

echo -n "Elige una opcion: "

read opcion

case $opcion in

a)

clear

echo "Mostrando los atributos del directorio actual"

ls -l .

read enterkey

;;

b)

clear

echo "Mostrando el contenido del directorio actual"

ls

read enterkey

;;

c)

clear

echo -n "Indica el nombre de un fichero: "

read fichero

if test -f $fichero; then

cat $fichero

fi

read enterkey

;;

d)

exit

;;

*)

clear

echo "La opcion $opcion no esta en la lista"

read enterkey

;;

esac

done

Software

Apuntes de shell script