Seminario Profesional:

BASH Shell
Objetivo
 Presentar las principales características del interprete Bash
Shell y familiarizar al alumno con su uso.

 Conocer su sintaxis, arquitectura y funciones generales así

como algunas herramientas para su depuración.

 El alumno deberá entender las capacidades y limitaciones de

este intérprete así como comenzar su uso tanto en su
plataforma de desarrollo (desktop) como en sus sistema
embebido (e.g. pandaboard).

 Al finalizar esta unidad el alumno deberá ser capaz de manejar

las instrucciones y construir programas (scripts) ejecución de
secuencias de instrucciones del sistema operativo Linux.

2
¿Que es Bash Shell ?

 Cada sistema operativo tiene su propio shell (e.g. Windows command promt)
cuya función principal es el interpretar las órdenes del sistema operativo

 Bash (Bourne again shell) es un programa escrito para el proyecto GNU y está
basado en el shell de Unix. Es compatible con POSIX (IEEE POSIX
P1003.2/ISO 9945.2).

 Bash es el intérprete de instrucciones más usado en las distribuciones de Linux,

es compatible en su mayoría con Unix shell sh e incorpora algunas de las
mejores características de Korn shell ksh y de C shell csh.

 La especificación definitiva de la sintaxis de órdenes de Bash, puede

encontrarse en:
http://www.gnu.org/software/bash/manual/bashref.html

3
Programas compilados vs Scripting
 Bash es no sólo un eficiente interprete de línea de instrucciones, sino también un
poderoso lenguaje scripting. El cual nos permite automatizar tareas que de otra
manera deberían realizarse de manera manual en la línea de comandos.

 Diferencia entre programación compilada y lenguajes scripting:

- Los lenguajes de programación son en general más poderosos y más veloces que los
lenguajes interpretados o scripting. Su código fuente es compilado tomando en
consideración la arquitectura del CPU, lo que genera un archivo ejecutable. Su
principal desventaja es que dichos ejecutables no pueden ser portados en otros
arquitecturas o incluso en otros sistemas operativos.

- El código fuente de un lenguaje scripting no es compilado en un ejecutable, en su

lugar es leído e interpretado una línea a la vez. Esto hace que dichos programas o
scripts puedan ser ejecutados en otras arquitecturas o sistemas operativos siempre
que estos cuenten con los intérpretes nativos correspondientes.
Programa (script) de bash
 En un editor de texto escribir las siguientes 2 líneas y salvar como Hola.sh.
#!/bin/bash
echo “Hola Mundo”
La primer línea le dice a Linux que use el interprete de bash para ejecutar el script.

 Antes de ejecutarlo hay que habilitar los permisos de ejecución del archivo:

$ ls -la Hola.sh
-rw-r--r-- Hola.sh
$ chmod 700 Hola.sh
$ ls -la Hola.sh
-rwx------ Hola.sh
$ ./Hola.sh
Hola Mundo

Para los archivos scripts utilizamos la extensión .sh para poderlos identificar de otro
tipo de archivos
Variables
 Las Variables son almacenados como tipo cadena de texto «Strings»

 Existen operadores matemáticos que convierten las cadenas de texto en variables

numéricas las cuales permiten el cálculo

 No es necesario declarar una variable. Estas se crean simplemente asignándole un

valor a su referencia
 Ejemplo Hola2.sh:

#!/bin/bash
El valor de la variable se
STR=“Hola Mundo”
recupera anteponiendo un
echo $STR símbolo ‘$’ a su nombre

$ chmod 775 Hola2.sh

$ ./Hola2.sh
Hola Mundo
Variables (cont.)
 En el lenguaje de programación de la shell las variables no están
asociadas a tipos de datos específicos «Types». Esto significa que una
misma variable puede usarse para contener datos numéricos o de texto
– Variable1=25630
– Variable1=”Hola mundo”
– Variable1=32445\*

 Buena práctica: Utilizar siempre el tipo de dato en cada una de las

variables del script

 Nota: \ es el carácter ascii de bash usado para preservar el valor literal del
siguiente carácter en la cadena « \ : escape character»
$ ls \*
ls: * : No such file or directory
Comillas simples y dobles
 Cuando se asignan cadenas de caracteres que contengan espacios en blanco o caracteres
especiales, se acostumbra encerrar la cadena entre comillas simples (apostrofes) o comillas
dobles

 Las comillas dobles harán que si, dentro de su contenido se referencia una variable (e.g.
$var), ésta sea resuelta a su valor
$ var=“test string”
$ new_var=“Value of var is $var”
$ echo $new_var
Value of var is test string

 Las comillas sencillas (apóstrofes) por el contrario harán que las variables (e.g. $var) NO
resuelvan su valor como parte de la cadena.
$ var=’test string’
$ new_var=’Value of var is $var’
$ echo $new_var
Value of var is $var

[Probar] : $ var='en mis tiempos “test string” era una lata'

Instrucción «export»
 Esta instrucción define una variable en el entorno de forma que sea accesible por los
procesos derivados Por ejemplo:
$ x=hola
$ bash # Llama a una nueva instancia del shell.
$ echo $x # En la nueva instancia la variable x no está definida
$ exit # Sale de la última instancia del shell hacia la instancia padre.
$ export x
$ bash # Llama de nueva cuenta a una nueva instancia del shell.
$ echo $x
hola # En este caso la variable sí está definida

 Si el proceso hijo modifica el valor de la variable x, esta no modificará el valor original del
proceso padre:
$ x=adios
$ exit
$ echo $x
hola
Variables de Ambiente
 Hay dos tipos de variables de entorno:
– Variables locales
– Variables de Ambiente, también llamadas variables de entorno
 Las Variables de Ambiente se establecen por el sistema « $ export foo=Hola ». y se pueden
listar utilizando la instrucción « env ».
 Dentro de las Variables de Ambiente contienen valores especiales. Por ejemplo:
$ echo $SHELL
/bin/bash
$ echo $HOME # argumento por defecto (directorio home) del comando «cd»
/home/jjcg

 Las Variables de Ambiente se definen en los archivos /etc/profile, /etc/profile.d/ y

~/.bash_profile. Los cuales son leídos durante la inicialización cuando se invoca al bash shell.

 Cuando un login shell termina su ejecución, el bash lee ~/.bash_logout

 El arranque del shell es más complejo; por ejemplo, si bash es usado de manera interactiva,
entonces /etc/bashrc o ~/.bashrc son leídos (Ver la documentación).
Variables de Ambiente (cont.)
 PATH: el path de búsqueda de comandos.
– Es una lista de directorios, separados por «:», en donde se busca cualquier comando.
$ echo $PATH
/usr/X11R6/bin:/usr/local/bin:/bin:/usr/bin

 Normalmente, ejecutamos un script de la siguiente manera:

./<nombre de la instrucción> $ ./my_script.sh

Pero estableciendo la variable PATH=$PATH:. se incluye el actual (.) directorio de trabajo dentro
del propio PATH y por la tanto podremos ejecutar el script como cualquier otra instrucción del
shell:
$ my_script.sh # sin el ./

 De manera más ordenada, si creamos el directorio ~/bin ($ mkdir ~/bin) y editamos el archivo
~/.bash_profile incluyendo las siguientes lineas:
PATH=$PATH:$HOME/bin
export PATH

estaremos incluyendo el directorio /home/«userid»/bin en el PATH y ahí podremos definir

nuestras propias instrucciones.
Variables de Ambiente (cont.)
– LOGNAME: contiene el nombre de usuario
– HOSTNAME: contiene el nombre de la máquina
– MACHTYPE: sistema hardware
– PS1: secuencia de caracteres mostrados antes del prompt «$»
• \t hora
• \d fecha
• \w directorio actual
• \W última parte del directorio actual
• \u nombre de usuario
• \$ carácter del prompt
Ejemplo: $ echo $PS1
$ PS1="Hola \u :\w\$"
$ echo $PS1
– UID: contiene el ID del usuario que no puede ser modificado
– SHLVL: contiene el nivel de anidamiento de la shell
– RANDOM: generador de números aleatorios
– SECONDS: segundos transcurridos desde el inicio de la ejecución
– HOME, TERM, TZ, ...
Variables Intrínsecas
– $#: número de argumentos
– ${N} : Nvo parámetro de la instrucción
– $$ : process ID
– $? : exit status (devuelve el valor de salida de la última orden ejecutada)
– $* : todos los argumentos de la shell
– $@ : semejante a la variable anterior
– $- : opciones suministradas a la shell
– $! : identificación del proceso de la última orden que comenzó con &
Ejemplo: #!/bin/bash
echo “Hola Mundo”
$ ./Hola.sh Par1 Par2 Par3
STR=32445\* “Hola Mundo”
Var2=${2} 32445*
echo $STR 3
echo $# Par2
4060
echo $Var2
echo $$
Instrucción exit
 La instrucción « exit » se puede utilizar para finalizar la ejecución de un script o para
devolver un valor, el cuál estará disponible para el proceso padre del script.
exit xxx # donde xxx=0-255
– Cuando un script termina con « exit » sin parámetros, el estado de salida será
el correspondiente al de la última instrucción ejecutada por el script

#!/bin/bash #!/bin/bash

INSTRUCCIÓN_1 INSTRUCCIÓN_1

. . . . . .
exit 3
# sale con el estado de la ejecución
# de la última instrucción. # sale con el estado de la ejecución
ULTIMA_INSTRUCCIÓN # de la última instrucción.
ULTIMA_INSTRUCCIÓN
exit
exit 0
Command Substitution
 El símbolo de acento invertido «`» lo utiliza la sintaxis del shell como modificador de contexto. Su efecto
es la de transferir la salida de la instrucción al ambiente del shell. En estos casos en lugar de
considerarse la cadena de caracteres ahí contenidos se tomará en cambio el resultado de la ejecución de
dicha cadena. (e.g.: var=`instrucción`)
$ LISTA=`ls`
$ echo $LISTA
hola.sh leer.sh

 Otra alternativa para la «sustitución de comandos» es: $(instrucción)

$ LISTA=$(ls)
$ echo $LISTA
hola.sh leer.sh
Ejemplos:
$ ls $( pwd )
$ ls $( echo /bin )
$ rm $( find ~/ -iname “*.tmp” )

$ cat > backup.sh

#!/bin/bash
BCKUP=/home/userid/backup-$(date +%d-%m-%y).tar.gz
tar -czf $BCKUP $HOME
Instrucciones simples y pipelines
 Las instrucciones simples, como se ha visto, son cadenas de caracteres que tienen
un significado para el intérprete del shell.
 La primera palabra de la cadena es la instrucción

 Las instrucciones pueden combinarse mediante los siguientes operadores:

– ; cmd1; cmd2; ... : ejecución secuencial
– & cmd1 & : ejecución asíncrona
– && cmd1 && cmd2 ... : ejecuta cmd2 sólo si la salida de cmd1 fue exit 0
– || cmd1 || cmd2 : ejecuta cmd2 sólo si la salida de cmd1 fue distinta
de cero

 En el caso de los Pipeline lo que se obtiene son cadenas de instrucciones simples

– Pipeline = instrucción « parámetros » | instrucción « parámetros » | ...

 Cada nueva instrucción interpreta la salida de la instrucción anterior

Instrucciones simples y pipelines (cont.)
 Ejemplo:
$ cat > ligas_simbolicas.sh
#!/bin/bash
# Variable de salida (nombre del archivo a guardar)
OUTFILE=symlinks.list
directory=${l-`pwd`}
# -type l == archivos de liga simbólica
for file in “$( find $directory -type l )”
do
echo “$file”
done | sort >> “$HOME/$OUTFILE”
exit 0
Instrucción read
 La instrucción « read » nos permite solicitar un valor de entrada para almacenarlo en una
variable
Ejemplo: (BorrarFile.sh)
#!/bin/bash
echo -n “Introduzca nombre del archivo a borrar: ”
read file_name
rm -i $file_name
echo “Archivo $file_name borrado!"

 Opciones
– read -s (no hace echo de la entrada)
– read -nN (acepta sólo N caracteres de entrada)
– read -p “mensaje” (muestra un mensaje)
– read -tT (acepta una entrada por un tiempo máximo de T segundos)
Ejemplo
$ read -s -n1 -p "si (S) o no (N)?" respuesta
si (S) o no (N) ? N
$ echo $respuesta
N
Manipulación de strings
 Varias opciones para manipular strings están disponibles en bash
${#string} regresa la longitud del string
${string:position} regresa el segmento de la cadena (string) desde la
posición marcada por $position
${string:position:length} regresa $length elementos de la cadena (string)
desde la posición marcada por $position

 Ejemplos:
$ variable=0123456789
$ echo ${#variable}
10
$ echo ${variable:6}
6789
$ echo ${variable:6:2}
67
Verificación de variables
 Para verificar si una variable está definida se puede usar:
${parameter?msg}
Si el parámetro ($parameter) existe, se envía a la salida
de lo contrario se imprime el mensaje msg

$ unset valor
$ unset total
$ valor=${total?'total no está definido'}
total: total no está definido
$ echo $valor

$ total=10
$ valor=${total?'total no está definido'}
$ echo $valor
10
Operadores aritméticos
+ suma
- resta
* multiplicación
/ división
** exponente
% módulo
Ejemplos:
$ a=(5+2)*3
$ echo $a
$ b=2**3
$ echo $a+$b
Evaluación aritmética
 Con la instrucción « let » se puede utilizar para realizar funciones matemáticas:
$ let X=10+2*5
$ echo $X No es necesario utilizar $X
20 para referenciar el valor de X
$ let Y=X+2*4
$ echo $Y
28
 Un expresión aritmética se puede evaluar con $[expresión] o $((expresión))
$ echo $((123+20))
143
$ VALOR=$[123+20]
$ echo $[50*$VALOR]
7150
$ echo $[2**3]
8
$ echo $[8%3]
2
Evaluación aritmética (cont.)
 Ejemplo (operaciones.sh)
#!/bin/bash
echo -n “Introduzca un primer número: ”; read x
echo -n “Introduzca un segundo número : ”; read y
suma=$(($x + $y))
resta=$(($x - $y))
mul=$(($x * $y))
div=$(($x / $y))
mod=$(($x % $y))

# imprimimos las respuestas:

echo “Suma: $suma”
echo “Resta: $resta”
echo “Multiplicación: $mul”
echo “División: $div”
echo “Módulo: $mod”
Estructuras de control condicional (if)
 Los condicionales nos permiten controlar el flujo del programa mediante la toma de decisiones
en base al resultados de las expresiones evaluadas.

if [ expresión ];
then
instrucciones
elif [ expresión ];
then
instrucciones
else
instrucciones
fi

 Las secciones elif (else if) y else son opcionales

Nota: Tanto después de [ como antes de los paréntesis rectangulares ] se requieren de

espacios para que los operandos y operadores puedan ser correctamente interpretados por el
shell.
Expresiones
 Una expresión puede estar definida por: comparación de cadenas, comparación
de variables numéricas, operadores de archivo así como operadores lógicos.
Las expresiones se representan mediante [ expresión ];

 Comparación de cadenas de caracteres:

= evalúa si dos cadenas son iguales
!= evalúa si dos cadenas son diferentes
-n evalúa si la longitud de la cadena es mayor que 0
-z evalúa si la longitud de la cadena es igual a 0

 Ejemplos:
[ s1 = s2 ] (verdadero si s1 es igual a s2)
[ s1 != s2 ] (verdadero si s1 es diferente a s2)
[ s1 ] (verdadero si s1 no está vacía)
[ -n s1 ] (verdadero si s1 tiene longitud mayor que 0)
[ -z s2 ] (verdadero si s2 tiene longitud igual a 0)
Expresiones (cont.)
 Comparación numérica con [ ] :
-eq evalúa si dos números son iguales
-ne evalúa si dos números son diferentes

-ge evalúa si el primer número es mayor o igual que el segundo

-le evalúa si el primer número es menor o igual que el segundo

-gt evalúa si el primer número es mayor que el segundo

-lt evalúa si el primer número es menor que el segundo

 Ejemplos:
[ n1 -eq n2 ] (verdadero si n1 es igual a n2 )
[ n1 -ne n2 ] (verdadero si n1 es diferente a n2 )
[ n1 -ge n2 ] (verdadero si n1 es mayor o igual a n2 )
[ n1 -le n2 ] (verdadero si n1 es menor o igual a n2 )
[ n1 -gt n2 ] (verdadero si n1 es mayor que n2 )
[ n1 -lt n2 ] (verdadero si n1 es menor que n2 )
Ejemplos $ cat > comparacion2.sh
#!/bin/bash
echo -n “Introduzca un número entre 1 y 10: "
$ cat > comparacion1.sh read num
#!/bin/bash if [ “$num” -lt 10 ]; then
if [ “$num” -gt 1 ]; then
echo -n “Introduzca su nombre de usuario: "
echo “$num*$num=$(($num*$num))”
read login
fi
if [ “$login” = “$USER” ]; then else
echo “Hola, $login. Cómo está hoy?” echo “Número fuera del intervalo!”
else fi
echo “Tú no eres $login!!!” echo -n "Introduzca otro número entre 1 y 10: "
fi read num
if (( $num <= 10 )); then
if (( $num >= 1 )); then
echo "$num**$num=$(($num**$num))"
fi
else
echo "Número fuera del intervalo!"
fi
Expresiones (cont.)
 Operadores de archivos:
-d evalúa si el path dado es un directorio
-f evalúa si el path dado es un archivo
-e evalúa si el archivo existe
-s evalúa si el archivo tiene un tamaño mayor a 0 bytes
-r evalúa si el archivo tiene permiso de lectura
-w evalúa si el archivo tiene permiso de escritura
-x evalúa si el archivo tiene permiso de ejecución

 Ejemplos:
[ -d cadena_de_caracteres ] (verdadero si la cadena corresponde a un directorio)
[ -f cadena_de_caracteres ] (verdadero si la cadena corresponde a un archivo )
[ -e cadena_de_caracteres ] (verdadero si existe )
[ -s cadena_de_caracteres ] (verdadero si el archivo tiene datos )
[ -r cadena_de_caracteres ] (verdadero si el archivo tiene permiso de lectura )
[ -w cadena_de_caracteres ] (verdadero si el archivo tiene permiso de escritura )
[ -x cadena_de_caracteres ] (verdadero si el archivo tiene permiso de ejecución )
Ejemplos: operadores de archivos
$ cat > comparacion3.sh $ cat > comparacion4.sh
#!/bin/bash #!/bin/bash
echo -n “Introduzca el nombre de un archivo: " if [[ $1 = “directory” ]]; then
read file_name find /etc -maxdepth 1 -type d
# if [ -f /etc/fstab ]; then elif [[ $1 = “link” ]]; then
if [ -f $file_name ]; then find /etc -maxdepth 1 -type l
cp $file_name . elif [[ $1 = “file” ]]; then
echo “Archivo $file_name copiado” find /etc -maxdepth 1 -type f
else else
echo “El archivo $file_name no existe !!!” echo "Usage: $0 file | directory | link "
exit 1 fi
fi

Nota: El uso reiterado de elif resulta en una ejecución ineficiente. Para casos donde se
requiera la verificación reiterada de un valor se favorece el uso del condicional case.
Operadores lógicos
! negación (NOT) seguida de la expresión lógica
-a operación AND entre dos expresiones lógicas
-o operación OR entre dos expresiones lógicas

&& operación AND entre dos expresiones lógicas

|| operación OR entre dos expresiones lógicas
Ejemplos:
$ nano operadores_logicos1.sh $ nano operadores_logicos2.sh
#!/bin/bash #!/bin/bash
echo -n "Teclee un número entre 1 y 10 " echo -n "Teclee un número entre 1 y 10 "
read num read num
if [ “$num” -gt 1 -a “$num” -lt 10 ]; then if [ “$num” -gt 1 ] && [ “$num” -lt 10 ]; then
echo "$num*$num=$(($num*$num))" echo "$num*$num=$(($num*$num))"
else else
echo "Número fuera de intervalo " echo "Número fuera de intervalo "
fi fi
Estructuras de control condicional (case)
 Usada para evaluar condicionales relativas a expresiones con valores específicos. Utilizadas para
remplazar largas cadenas de condicionales if - elif - elif ... - else.

 Cada grupo de evaluación de expresiones e instrucciones relacionadas debe separarse con punto y
coma dobles « ; ; ».
$ cat > case.sh
case $var in #!/bin/bash
val_1 ) case $1 in
instrucciones ;; “directory”)
val_2)
find /etc -maxdepth 1 -type d ;;
instrucciones ;;
“link”)
val_n)
find /etc -maxdepth 1 -type l ;;
instrucciones ;;
“file”)
*)
find /etc -maxdepth 1 -type f ;;
instrucciones ;;
esac *)
echo "Usage: $0 file | directory | link " ;;
esac
 El *) usado para aceptar cualquier otra
condición no listada en las anteriores opciones
Estructuras tipo while
 Las estructuras tipo « while » son estructuras de repetición cíclica usadas para
ejecutar un conjunto de instrucciones de manera reiterada tanto la condición
definida sea verdadera.

 Su ejecución finaliza cuando al inicio de un nuevo ciclo la evaluación de la

condicionante resulta falsa. Si esto no llegase a ocurrir entonces la repetición
sería infinita.
$ cat > while_loop.sh
#!/bin/bash
COUNT=10
while [expresión]
while ((COUNT > 0))
do do
instrucciones echo -e “$COUNT \c ”
... sleep 1
instrucciones ((COUNT --))
done done
echo
echo ”Fin del ciclo”
Estructuras tipo while - true
$ cat > case.sh
 Cuando la condición en la estructura tipo
«while» es forzada para ser siempre #!/bin/bash
verdadera la única alternativa para salir del while true
ciclo es el uso de la instrucción « exit ». do
echo -e "Enter directory, link, file or q to quit: \c"
while true read DIR
if [[ $DIR = q ]] then
do
exit
instrucciones
fi
… case $DIR in
if [ expresión ]; then "directory")
instrucciones find /etc -maxdepth 1 -type d ;;
exit "link")
fi find /etc -maxdepth 1 -type l ;;
instrucciones "file")
find /etc -maxdepth 1 -type f ;;
done
*)
echo "Usage: $0 file | directory | link | q " ;;
esac
done
Menús
 Mediante las estructuras tipo case dentro de un ciclo $ nano menu_script.sh
while pueden usarse para dar vida a menús de #!/bin/bash
opciones tipo: clear ; loop=y
while [ “$loop” = y ] ;
while [expresión] do
echo “Menu”; echo “====”
do
echo “D: print the date”
instrucciones
echo “W: print the users who are currently log on.”
… echo “P: print the working directory”
case $var in echo “Q: quit.”
val_1 ) echo
instrucciones ;; read –s choice # silent mode: no echo to terminal
val_2) case $choice in
instrucciones ;; D | d) date ;;
val_n) W | w) who ;;
P | p) pwd ;;
instrucciones ;;
Q | q) loop=n ;;
*)
*) echo “Illegal choice.” ;;
instrucciones ;; esac
esac echo
instrucciones done
done
Estructuras tipo until
 Las estructuras tipo until son muy similares a las $ echo hola > /tmp/file1
estructuras tipo while. Las instrucciones dentro del $ du -b /tmp/file1
lazo se ejecutan HASTA que la expresión cambie $ nano until_loop.sh
su condición a verdadera. #!/bin/bash
COUNT=1
SZ=$(du -b /tmp/file1 | cut -f1)
until ((SZ > 100))
do
until [expresión] echo -e “$SZ \c ”
do echo “ Esta es la línea $COUNT” >> /tmp/file1
sleep 1
instrucciones
((COUNT ++))
... SZ=$(du -b /tmp/file1 | cut -f1)
instrucciones done
done echo
echo ”El archivo contiene más de 100 bytes!!!”
$ chmod +x until_loop.sh
$ ./until_loop.sh
$ cat /tmp/file1
Estructuras tipo for
 Estas son estructuras cíclicas cuyas repeticiones están
delimitadas en un intervalo definido.

for var in list $ cat > for_loop.sh

do #!/bin/bash
let sum=0
instrucciones
for num in 1 2 3 4 5
... do
instrucciones let “sum = $sum + $num”
done done
echo $sum
Ejemplos ciclos for
Si el parámetro lista es omitida, entonces la
variable var asumirá los parámetros que se le
pasan al script (i.e. $1, $2, $3,…)

$ cat > for_loop2.sh

$ cat > for_loop1.sh #!/bin/bash
#!/bin/bash for x
for x in piedra papel tijera do
do echo “El valor de x es: $x”
echo “El valor de x es: $x” sleep 1
sleep 1 done
done
$ chmod +x for_loop2.sh
$ ./for_loop2.sh arg1 arg2 arg3
Ejemplos ciclos for
$ cat > for_loop3.sh
#!/bin/bash
for file in $(ls)
do
[ ! -f $file ] && continue
DT=$(stat $file | grep Access | tail -1 | cut -d " " -f2 )
echo -e "\n El archivo $file es de $(du -b $file | cut -f1) bytes \c"
echo -e "y fue abierto por última vez el $DT \c "
sleep 1
done
echo
Estructuras for en formato tipo C
 Una alternativa al formato de las estructuras for es la de:
for ((expresión1, expresión2; expresión3))
do
instrucciones
done

 En primer lugar se evaluá la expresión1. Acto seguido se evalúa la expresión2 hasta

que su resultado sea 0. Cada vez que el resultado de la evaluación de expresión2 sea
distinta 0, las instrucciones del ciclo son ejecutadas y finaliza con la expresión3 siendo
evaluada.

$ cat for_loop4.sh
#!/bin/bash
echo –n “Introduzca un número: ”; read x
let suma=0
for (( i=1 ; $i<$x ; i=$i+1 )) ; do
let “suma = $suma + $i”
done
echo “La suma de los primeros $x números es: $suma”
Operador continue
 El operador continue produce un salto a la siguiente iteración cuando se
encuentra dentro de la ejecución de un ciclo, evitándose la ejecución de las
subsiguientes instrucciones dentro del lazo.

$ cat continue.sh
#!/bin/bash
LIMIT=19
echo
echo “Imprimir los números del 1 al 20 (excepto 3 y 11)”
a=0
while [ $a -le “$LIMIT” ]; do
a=$(($a+1))
if [ “$a” -eq 3 ] || [ “$a” -eq 11 ]
then
continue
fi
echo -n “$a ”
done
Operador break
 El operador break, cuando se ejecuta, termina con las iteraciones del ciclo.
Simplemente lo rompe.

$ cat break.sh
#!/bin/bash
LIMIT=19
echo
echo “Imprimir los números del 1 al 20 ( pero al llegar al 2 ... )”
a=0
while [ $a -le “$LIMIT” ]; do
a=$(($a+1))
if [ “$a” -gt 2 ]
then
break
fi
echo -n “$a ”
done
Arreglos (listas)
 En bash se pueden definir arreglos. La forma más simple de hacerlo es
mediante: transporte=(automovil avion barco bicibleta) o de manera
explícita:

oficio[0]=carpintero
oficio[1]=ingeniero
oficio[2]=plomero

 Se pueden definir hasta 1024 elementos en cada arreglo, para extraer un

elemento en particular se utiliza el siguiente formato : ${array_name[i]}

my_oficio=${oficio[1]} for x in ${transporte[*]}

echo ${oficio[2]} do
echo $x
done
echo ${transporte[*]}
Arreglos (listas)
Ejemplos:
 Enlista todos los archivos en el directorio actual
$ nano lista1.sh $ nano lista1b.sh
#!/bin/bash #!/bin/bash
for x in * arreglo=${l-`ls`}
for x in ${arreglo[*]}
do
do
ls -l “$x”
ls -l “$x”
sleep 1
sleep 1
done done

 Enlista todos los archivos en /bin

$ nano lista2.sh
#!/bin/bash
for x in /bin
do
ls -l “$x”
sleep 1
done
Operaciones en variables
 += #incrementa la variable
 -= # decrementa la variable
 *= # multiplica la variable
 /= # divide la variable

let “index += 5” #incrementa el valor en 5 unidades

let “count *= 2” # duplica el valor de la variable

Depuración
 Bash ofrece dos formas de depurar los shell scripts
-v : muestra cada línea completa del script antes de ser ejecutada
-x : muestra cada línea abreviada del script antes de ser ejecutada

– Uso: #!/bin/bash -v o #!/bin/bash -x

$ nano depurar.sh
#!/bin/bash -x
echo -n “Introduzca un número: ”; read x
let sum=0
for (( i=1 ; $i<$x ; i=$i+1 )) ; do
let “sum = $sum + $i”
done
echo “La suma de los $x primeros números es: $sum”
 Depuración
 Ejemplo -x  Ejemplo -v
$ ./depurar.sh $ ./depurar.sh
+ echo -n 'Introduzca un número: ' #!/bin/bash -v
Introduzca un número: + read x echo -n "Introduzca un número: "; read x
3 Introduzca un número: 3
+ let sum=0 let sum=0
+ (( i=1 )) for (( i=1 ; $i<$x ; i=$i+1 )) ; do
+ (( 1<3 )) let "sum = $sum + $i"
+ let 'sum = 0 + 1' done
+ (( i=1+1 )) echo "La suma de los $x primeros números es:$sum"
+ (( 2<3 )) La suma de los 3 primeros números es: 3
+ let 'sum = 1 + 2' $
+ (( i=2+1 ))
+ (( 3<3 ))
+ echo 'La suma de los 3 primeros números es: 3'
La suma de los 3 primeros números es: 3
$
Ejemplo: grep + nano
$ nano grepedit.sh
#!/bin/bash
# Si los archivos listados en los parámetros $2 en adelante incluyen
# la cadena de caracteres (pattern) del argumento $1 serán abiertos con “nano”
if [ $# -le 1 ]
then
echo "Usage: $0 pattern file1 …" ; exit 1
else
pattern=$1 # Guardar el parámetro $1 original en “pattern”
shift # Correr un lugar hacia la izquierda el resto de parámetros
while [ $# -gt 0 ]; # El nuevo $1 contiene ahora el primer nombre de archivo
do
grep "$pattern" $1 > /dev/null
if [ $? -eq 0 ] ; then # Si grep encuentra una coincidencia
nano $1 # el archivo es abierto con el editor nano
fi
shift
done
fi
echo “La suma de los $x primeros números es: $sum”
Funciones
 En bash se pueden definir funciones usando sólo el nombre de la función [ e.g. Nombre( ) ] o
usando la instrucción « function »
$ nano funcion.sh
#!/bin/bash
hello()
{
echo "You are in function hello()"
}
function Hola()
{
echo "Ahora está dentro de la función Hola()"
}
echo "Calling function hello()…"
hello
echo "You are now out of function hello()"
echo
echo "Llamando a la función Hola()…"
Hola
echo "Ahora está afuera de la función Hola()"
Funciones (cont.)
 Ejemplo

$ nano funcion.sh
#!/bin/bash
function check() {
if [ -e "/home/$1" ]
then
return 0
else
return 1
fi
}
echo “Introduzca el nombre del archivo: ” ; read x
if check $x
then
echo “$x existe !”
else
echo “$x no existe !”
fi
Ejemplo Script1.sh
 Selección de una carta aleatoria de una baraja de cartas

$ nano script1.sh
#!/bin/bash
# Paso I : Listar los elementos
Palo=“Bastos Diamantes Corazones Espadas”
Denominaciones=“2 3 4 5 6 7 8 9 10 Joto Qüina Rey Ás”

# Paso II : Pasar los arreglos a variables

palo=($Palo)
denominaciones=($Denominaciones)

# Paso III : Contar el número de elementos

num_palo=${#palo[*]}
num_denominaciones=${#denominaciones[*]}
echo -n "${denominaciones[$((RANDOM % num_denominaciones))]} de "
echo ${palo[$((RANDOM % num_palo))]}
exit 0
Ejemplo Script2.sh
 Conversión de los nombres de archivos a minúsculas

$ nano script1.sh
#!/bin/bash
# Paso I : Recorrer todos los archivos en el directorio
for filename in *
do
# Obtener el nombre del archivo sin path.
fname=`basename $filename`

# Cambiar los nombres a minúsculas.

n=`echo $fname | tr A-Z a-z`

# Renombrar sólo aquellos archivos con nombres en mayúsculas.

if [ “$fname” != “$n” ]
then
mv $fname $n
fi
done
exit 0