Shell Script; Estructuras de Control

 Bash incluye lo que cualquier lenguaje de programación necesita, las comprobaciones condicionales y los ciclos.

Una comprobación(test) es (test en español se traduce como prueba), como su nombre lo dice simplemente una función que se usa para verificar que determinada condición se cumpla (o bien que no); Mientras que un ciclo es un conjunto de instrucciones que se repitan mientras o hasta que la condición se cumpla.

La estructura condicional sirve para comprobar si se ejecuta un bloque de código cuando se cumple una cierta condición. Pueden anidarse varias estructuras dentro del mismo bloques de código, pero siempre existe una única palabra fi para cada bloque condicional.

Lo más básico. If then:

La estructura básica de este condicional va de la siguiente manera

[color=#000000]if expresion;
    then
        bloque;
fi[/color]

Como podemos ver el if se cierra con fi que al parecer un juego de palabras es fácil de recordar. Así tenemos que si se cumple la condición entraría por el then y finalizaría. Veamos un ejemplo.

[color=#000000]#! /bin/bash

clear
read -p "Cuanto es 9 * 9 " res
mult=$(echo "9*9" | bc -l)
if test $res == $mult
    then
        echo "El resultado es correcto"
fi[/color]

Explicación: Como podemos ver este script al ser ejecutado nos pide el resultado de la multiplicación de 9 y 9 y lo guarda en la variable $res, luego utilizamos lo que vimos en el capitulo anterior de operaciones aritméticas con bc para declarar la variable $mult. Algunos dirán: “¿No era más fácil decir que $mult= 8?” pues si, pero de esta manera practicamos lo de las operaciones aritméticas, lo de guardar comandos en variables y además así me parece más divertido que un insípido 81. Luego de esto entramos en el condicional y decimos que si se cumple la condición (Que la variable $res es igual a la variable $mult) entonces (then) mostramos en pantalla el mensaje “El resultado es correcto”.

Como vemos donde comienza el condicional if utilizamos la función test que como dijimos anteriormente nos verifica si se cumple la condición. Otra manera de hacer esto sin el test seria:

[color=#000000]if [ $res == $mult
 ]
    then
        echo "El resultado es correcto"
fi[/color]

Nota: Como vemos los corchetes remplazan el test. Pero cuidado, es importante respetar los espacios, si no no funciona. If (espacio) [ (espacio) condición (espacio) ].

Ahora bien, para los que ya se han preguntado “¿Y que pasa si no doy el resultado que es?” Si dejamos el script como esta simplemente no hará nada. “Pero yo quiero que me responda si me equivoco”, ok, para eso tenemos el else y funciona de la siguiente manera.

[color=#000000]#! /bin/bash

clear
read -p "Cuanto es 9 * 9 " res
mult=$(echo "9*9" | bc -l)
if [ $res == $mult
 ]
    then
        echo "El resultado es correcto"
else
    echo "Te has equivocado, el resultado es $mult"
fi[/color]

En español seria algo como: Si (if) lo que tu escribiste por el terminal ($rest) es igual a lo que es el verdadero resultado de 9 * 9 ($mult) entonces (then) muestra el mensaje “El resultado es correcto” si no (else) muestra el mensaje “Te has equivocado, el resultado es el verdadero valor de 9*9 ($mult)”

Ahora vamos a ponerle algo más de sabor al asunto. ¿Que tal si la persona al poner un numero cercano al resultado verdadero nos diga que estamos cerca.? Vamos a ello

[color=#000000]#! /bin/bash

clear
read -p "Cuanto es 9 * 9 " res
mult=$(echo "9*9" | bc -l)
if [ $res == $mult ]
    then
        echo "El resultado es correcto"
elif [ $res == 80 ] || [ $res == 82 ]
    then
        echo "Estuviste cerca pero no"
else
    echo "Te has equivocado, el resultado es $mult"
fi[/color]

Lo que se ve nuevo aquí es el elif y dentro de este probamos si la variable $res es igual a 80 o igual a 82 para el o usamos el operador lógico || entonces en español seria algo como: si (if) la variable $res es igual a la variable $mult entonces (then) muestra el mensaje “El resultado es correcto” pero si (elif) la variable $res es igual a 80 o (||) aigual a 82 muestra el mensaje “Estuviste cerca pero no” si no se cumple ninguna de las condiciones (else) muestra el mensaje “Te has equivocado, el resultado es $mult (81)”.

Veamos otro ejemplo que comprueba si existe la ruta a un directorio y muestra lo que tiene..

[color=#000000]#! /bin/bash

clear
read -p "Ruta al directorio: " ruta
if [ -e $url ]
    then
        echo "Si es un directorio y contiene: "
        ls -l $ruta
else
    echo "No es un directorio"
fi[/color]

Explicación: Como siempre limpiamos la pantalla, solicitamos la ruta al directorio (Ejemplo: /var/www/joomla/) y la guardamos en la variable $ruta luego utilizamos -e para comprobar que la ruta al directorio existe y si se cumple la condición entonces muestra el mensaje “Si es un directorio y contiene: ” y a continuación con ls -l mostramos la lista de todo lo que contiene el directorio, sencillo ¿no?.

Case Esac

Este tipo de sentencia, seria al equivalente al swicht en lenguaje C. Como otro tipo de estructura seria el equivalente a una serie de if anidados, con estos podría obtener el mismo resultado, la diferencia es que usando la sentencia case, el algoritmo es mas ordenado y completo.

vamos a ver el mismo ejemplo de hace rato pero con case:

[color=#000000]#! /bin/bash

clear
read -p "Cuanto es 9 * 9 " res
case $res in
    81)
        echo "El resultado es correcto"
    ;;
    80182)
        echo "Estuviste cerca pero no"
    ;;
    *)
        echo "Te has equivocado, el resultado es 81"
    ;;
esac[/color]

Explicación: Igual que en el ejemplo anterior pedimos que se introduzca un número por la terminal y lo guardamos en la variable $res y básicamente decimos que en caso de que la variable $res sea 81 me muestre el mensaje “El resultado es correcto”, en caso de que sea 80 u 82 “Estuviste cerca pero no” y en caso de que sea otro numero “Te has equivocado, el resultado es 81” aquí vemos el uso del operador binario | para comprobar si la variable $res es 80 u 82. El asterisco * en este caso es para indicar todo lo demas.

El siguiente ejemplo nos dice que tipo de tecla hemos presionado.

[color=#000000]#! /bin/bash

clear
read -n 1 -p "Pulsa cualquier tecla " tecla
clear
case $tecla in
    [a-z,A-Z])
        echo "Has introducido una letra"
    ;;
    [0-9])
        echo "Has introducido un numero "
    ;;
    *)
        echo "Has introducido un caracter especial"
    ;;
esac[/color]

Explicación: con la opción -n del comando read delimitamos la cantidad de caracteres que se pueden ingresar a 1 y guardamos el valor en la variable $tecla luego decimos que encaso de que la tecla presionada este entre la a y la zeta, mayúscula o minúscula [a-z,A-Z] muestre el mensaje “Has introducido una letra”, en caso de que sea un numero del 0 al 9 [0-9] muestre el mensaje “Has introducido un numero” y en caso contrario * muestre el mensaje “ Has introducido un carácter especial”.

Select

Para no tener que estar haciendo tantos echo y tener nuestros scripts mas ordenados, el bash nos ofrece un comando bastante útil, se trata de select, veamos como funciona.

[color=#000000]select variable in opcion1 opcion2
    do
        case $variable in
            opcion1)
                comando
            ;;
            opcion2)
                comando
            ;;
            *)
                comando
            ;;
        esac
    done[/color]

Ahora en funcionamiento con el siguiente script que nos permite elegir entre las opciones listar o salir.

[color=#000000]#! /bin/bash

clear
dir="/var/www/"
select opcion in lista salir
    do
        case $opcion in
            lista)
                ls -l $dir
            ;;
            salir)
                break
            ;;
            *)
                echo "Opcion incorrecta"
            ;;
        esac
    done[/color]

Explicación: declaramos la variable $dir como la ruta al directorio de nuestro servidor local /var/www/ y solicitamos que se introduzca la opción que se desea (1 lista o 2 salir). Para ello select nos da el prompt #? luego generamos la condición en caso de que se introduzca 1 se hará una lista del directorio y en caso de que se introduzca 2 se saldrá del script en caso de que se presione otra tecla se muestra el mensaje “Opción incorrecta”.

Recuerdan nuestro script para saber si un directorio existe? Vamos a mejorarlo y darle opciones

[color=#000000]#! /bin/bash

clear
read -p "Ruta al directorio: " ruta
if [ -d $ruta ]
    then
        PS3="$ruta Si es un directorio. Escoge una opcion: "
        select opt in lista salir
            do
                case $opt in
                    lista)
                        ls -l $ruta
                        break
                    ;;
                    salir)
                        break
                    ;;
                    *)
                        echo "Opcion Incorrecta"
                    ;;
                esac
            done
else
    echo "$ruta No es un directorio"
fi[/color]

Explicación: Guardamos la ruta que obtenemos por consola en la variable $ruta, creamos la primera condición; si la variable $ruta es un directorio entonces muestra el mensaje “Si es un directorio. Escoge una opcion: “ la variable global PS3 es algo parecido al read -p, en otro capitulo lo explicaremos bien, por ahora sabemos que nos hace escoger entre las opciones 1 y 2, lista y salir respectivamente, en caso de que escojamos 1 hará una lista con ls -l de la ruta incluid en la variable $ruta y saldrá, en caso de que la opción se 2 saldrá y en caso contrario nos dará el mensaje “ Opcion Incorrecta”y nos tendremos que ingresar 1 o 2 para continuar ahora en caso de que en un principio la ruta que hayamos puesto en la variable $ruta no sea valida nos dirá que “$ruta No es un directorio”.

El Clásico For

El ciclo for es ampliamente usado en programación en la mayoría de los lenguajes, en el cual por cada elemento en determinada variable se repetirán determinadas acciones, esto hasta que lo haya hecho con todos los elementos indicados, entonces el ciclo habrá terminado y solo entonces.

Se puede utilizar de las siguientes formas

[color=#000000]for i in var1 var2 var3 var4
    do
        echo "Esa es la variable $i"
    done[/color]

el valor de i se va sustituyendo por el valor de las variables en las que esta iterando así que el resultado seria

[color=#000000]Esta es la variable var1
Esta es la variable var2
Esta es la variable var3
Esta es la variable var4[/color]

Otra manera:

[color=#000000]for i in `seq 1 10` 
    do
        echo $i
    done[/color]

En este caso se pide iterar en los números comprendidos del 1 10 así que el bucle se ejecutara hasta llegar a 10 mostrando los números del 1 al 10

[color=#000000]for ((i=1;i<=20;i++))
    do
        echo "Prueba"
    done[/color]

Esta otra manera, que tambien es bastante usada en otros lenguajes, dice que la variable a evaluar es igual a x numero y menor o mayor que otro numero y se manda a auto-incrementar o auto-disminuir. En este caso la variable $i es igual 1 pero menor que 20 y se manda a auto-incrementar lo cual repetirá el comando echo “Prueba” Hasta que la variable $i llegue a 20.

Veamos un ejemplo. Supongamos que tenemos 10 directorios en una carpeta con nombres 1, 2, 3, etc y en uno de esos directorios hay un archivo llamado prueba.txt. Hagamos un script para conseguir ese archivo y poder borrarlo

[color=#000000]#! /bin/bash

clear
for ((i=1;i<=10;i++))
    do
        if [ -e /home/santiago/prueba_sh/prueba/$i/prueba.txt ]
            then
                cd /home/santiago/prueba_sh/prueba/$i
                pwd
                select opt in borrar salir
                    do
                        case $opt in
                            borrar)
                                rm prueba.txt
                                break
                            ;;
                            salir)
                                break
                            ;;
                        esac
                    done
            fi

    done[/color]

Explicación: primero decimos que la variable $i que será nuestro contador es igual a 1 y menor o igual a 10, de esta manera nos iterara entre el 1 y el 10 luego la mandamos a auto-incrementarse con el operador ++ luego verificaremos que la ruta /home/santiago/prueba_sh/prueba/$i/prueba.txt sea valida, donde $i es el nombre del directorio y cuando se cumpla la condición entrara al directorio con cd mostrara la ruta con pwd y luego nos dará la opción de eliminar el archivo (1) o salir (2) si ingresamos 1 borrara el archivo con rm y saldrá del script, si presionamos 2 saldrá del script.

While

While es una instrucción de control que sirve para generar bucles, en los cuales grupos de instrucciones se ejecutan de forma repetida hasta que se cumpla una condición. Cabe destacar que while, primero comprobará si se cumple la condición y si se cumple y sólo si se cumple entonces pasará a ejecutar secuencialmente las instrucciones contenidas entre do y done.

Cada vez que se ejecuta un bucle completo (paso de bucle) vuelve a verificar si se cumple la condición antes de volver a ejecutar otro paso de bucle.

Ejemplo de uso:

[color=#000000]while [ condicion ]
    do
        accion
    done[/color]

Las acciones entre "do" y "done" se repetirán secuencialmente mientras se cumpla la "condición lógica". Cuando la "condición lógica" deje de ser verdadera, no se ejecutará ninguna "acción". Por ejemplo:

[color=#000000]#! /bin/bash

clear
limite=5
i=0
while [ $limite -ge $i ]
    do
        echo "Accion $i ejecutada"
        let i=$i+1
    done[/color]

Explicación: Primero guardamos en una variable $limite un valor numérico, en este caso 5, y le damos valor a la variable $i que sera nuestro contador. Decimos que mientras se cumpla la condición de que la variable $limite mayor o igual que la variable $i se mostrara el mensaje “ Accion $i ejecutada” y nuestro contador aumentara 1, el resultado de este script seria algo como:

[color=#000000]Accion 0 ejecutada
Accion 1 ejecutada
Accion 2 ejecutada
Accion 3 ejecutada
Accion 4 ejecutada
Accion 5 ejecutada[/color]

Vemos que cuando la variable $i llega a 5 muestra por ultima vez el mensaje y se detiene el script, esto es porque al aumentar 1 valor mas,$i pasa a ser igual a 6 y como ya dijimos $limite es igual a 5 esto quiere decir que la condición de que $limite sea mayor o igual a $i deja de cumplirse por lo tanto se sale del bucle.

Veamos el ejemplo de la serie fibonacci con while

[color=#000000]#! /bin/bash

clear
read -p "Limite: " num
a=1
b=1
count=1
echo "Serie Fibonacci"
while [ $count -le $num ]
    do
        echo $b
        let b=$b+$a
        let a=$b-$a
        let count=$count+1

    done
exit[/color]

Pedimos un numero entero para guardarlo en la variable $num como limite declaramos las variables $a y $b que serán igual a 1 y la variable $count que sera nuestro contador y sera igual a uno. Luego iniciamos el bucle y ponemos como condición para que la variable $count sea menor o igual que la variable $num, mientras esta condición se cumpla se mostrara el valor de $b luego $b sera igual a su valor mas el valor de $a y $a sera igual a $b menos su propio valor, $count sera igual a su valor mas uno y se repetirá esto hasta que el contador llegue al valor de $num. Digamos que $num es 10, entonces el resultado sera algo como esto:

[color=#000000]Serie Fibonacci
1
2
3
5
8
13
21
34
55
89[/color]

Until

Until es igual que while pero se diferencia en que ahora el bucle se ejecuta mientras la condición sea falsa.

[color=#000000]#! /bin/bash

clear
num=50
until [ $num -eq 76 ]
    do
        echo "numero: $num"
        num=`expr $num + 1`
    done[/color]

En este ejemplo declaramos la variable $num con valor 50 y decimos que hasta que $num sea igual a 76 mostrara “numero: $num” y el valor de $num sera igual a su valor mas 1. Con esto obtendremos algo como esto.

[color=#000000]numero: 50
numero: 51
numero: 52
numero: 53
numero: 54
numero: 55
numero: 56
numero: 57
numero: 58
numero: 59
numero: 60
numero: 61
numero: 62
numero: 63
numero: 64
numero: 65
numero: 66
numero: 67
numero: 68
numero: 69
numero: 70
numero: 71
numero: 72
numero: 73
numero: 74
numero: 75[/color]

Vamos a ver un Script Interesante que se me ocurrió para quitarme la odiosa tarea de crear un archivo para cada script hecho para estos tutoriales con los comandos por consola o por la interfaz. Creé un script que solo me solicita el nombre del archivo para crearlo, escribir la primera linea con #! /bin/bash darle permisos de ejecución y abrirlo listo para editar.

#! /bin/bash

cd ~/prueba_sh/
clear
read -p "Nombre del archivo con su extensión: " fileName
if [ -e /home/santiago/prueba_sh/$fileName ]
then
echo "El archivo $fileName ya existe"
else
> $fileName
echo "#! /bin/bash" > $fileName
sudo chmod +x $fileName
gedit $fileName &
fi

Explicación: Me posiciono en el directorio donde estoy creando mis scripts que en este caso es prueba_sh, pido que se introduzca el nombre del archivo con todo y extensión y se guarda en la variable $fileName. Luego comprobamos si el archivo existe dentro del directorio en el que estamos creándolo, si existe se muestra el mensaje “ El archivo $fileName ya existe” si no procedemos a crear el archivo, le ponemos su primera linea #! /bin/bash pasamos a darle permisos de ejecución con chmod y lo abrimos con el editor gedit listo para trabajar en él.

Hasta aquí por ahora con todo esto de los condicionales y los bucles.. Espero que les sea de utilidad.

Shell Script; Las expresiones aritméticas y condicionales

Una expresión es una combinación de valores y operaciones que, al ser evaluados, entregan un valor.

El interprete bash soporta una gran variedad de expresiones en el desarrollo de programas, aquí veremos dichas expresiones.

1) Expresiones aritméticas:

A la hora de escribir un programa siempre se precisa de operaciones matemáticas básicas o complejas.

Aquí tenemos una lista de operaciones aritméticas:

Var++: Post-incremento de variable.
Var--: Post-decremento de la variable.
++Var: Pre-incremento de variable.
--Var: Pre-decremento de la variable.
+Expr: Más, numero positivo
-Expr: Menos, numero negativo
! Expr: Negación lógica
~ Expr: Negación binaria.
E1 ** E2 Exponente. E1 elevado a la E2.
E1 * E2: Multiplicación
E1 / E2: División.
E1 % E2: Resto.
E1 + E2: Suma
E1 – E2: Resta.
Expr << N: Desplazamiento binario a la izquierda un numero (N) de veces.
Expr >> N: Desplazamiento binario a la derecha un numero (N) de veces.
E1 < E2: Menor que
E1 > E2: Mayor que
E1 <= E2: Menor o igual que
E1 >= E2: Mayor o igual que
E1 = E2: Igualdad.
E1 != E2: Desigualdad.
E1 & E2: Operación binaria Y
E1 ^ E2: Operación binaria O exclusiva
E1 | E2: Operación binaria O
E1 && E2: Operación lógica Y
E1 || E2: Operación Binaria O
E1 ? E2 : E3 Evaluación Lógica Si E1=cierto, devuelve E2; si no, E3
E1 Op= E2: Asignación normal con pre-operación.(*=, /=, %=, +=, -=, <<=, >>=, &=, ^ =, !=) Funciona como E1 = E1 Op E2
E1, E2: Operaciones independientes. Se ejecutan en orden.

Veamos ahora como podemos utilizar algunos operadores aritméticos para realizar algunas operaciones matemáticas básicas: suma resta multiplicación división y módulos.

Comando expr.

expr 10 + 2
#Resultado 12

expr 10 - 2
#Resultado 8

expr 10 * 2
#Resultado 20

expr 10 / 2
#Resultado 5

expr 10 % 2
#Resultado 0

También podemos hacerlo utilizando el comando echo de la siguiente manera:

echo $((10+2))
#Resultado 12

echo $((10-2))
#Resultado 8

echo $((10*2))
#Resultado 20

echo $((10/2))
#Resultado 5

echo $((10%2))
#Resultado 0

Nota: Los comandos expr y echo solo admiten y devuelven enteros, Es importante utilizar espacios para las operaciones con expr, notese la diferencia en el siguiente ejemplo

expr 2+2 #todo pegado
#devuelve 2+2

expr 2 + 2 #con espacios
#devuelve 4

Al utilizar el asterisco * para una operación de multiplicación con el comando expr es importante hacerlo con una barra invertida, si no, nos da error. Ejemplo

expr 2 * 5
#devuelve error

expr 2 * 5 #la barra invertida va antes del * pero aquí no se visualiza
#devuelve 10

otra manera de realizar estas operaciones es con bc que es una potente calculadora que viene instalada en muchas distribuciones GNU/Linux. Par usar bc tenemos dos formas:

bc

abre la calculadora.

Colocas la operación que necesitas realizar

5*5

Al pulsar enter te devolverá el resultado en este caso:

25

quit

con quit salimos.

La otra manera es la siguiente:

echo "5*5" | bc -l
#Resultado 25

En este contexto la segunda manera de usar bc nos podría resultar útil pues como ya sabemos es posible guardar salidas de comandos en variables por ejemplo

$var=$(echo  "6*8" | bc -l)
echo $var
#Resultado 48

Veamos ahora un par de ejemplos.

#! /bin/bash 

clear 
echo "Operaciones Matemáticas" 
read -p "Ingresa el primer valor " val1 
read -p "ingresa el operador bien sea + - / o * " opr 
read -p "Ingresa el segundo valor " val2 
echo "Estamos procesando" 
sleep 2 
res=$(echo "$val1$opr$val2" | bc -l) 

echo $res

Explicación:

Como asumo que ya se han leído los dos tutoriales anteriores solo diré, de las lineas 4, 5 y 6 que pedimos los valores que usaremos y los guardamos en variables, el comando sleep sirve para detener un poco la ejecución del script para dar la sensación de que nuestro “Complejisimo programa calculadora esta leyendo miles de lineas de código para dar un resultado” XD por ultimo guardamos en una variable $res el comando para realizar la operación con bc e imprimimos la variable $res

Una manera mas sencilla pero mas eficaz pues nos permitirá realizar operaciones mas complejas seria:

#! /bin/bash 

clear 
echo "Operaciones Matemáticas" 
read -p "Ingresa tu operación " opr 
echo "Estamos procesando" 
sleep 2 
echo "$opr" | bc -l

con este código podríamos ingresar directamente operaciones como (2*2)*(5*5)-99 y arrojaría 1 como resultado.

2) Expresiones Condicionales

Las expresiones condicionales son evaluadas por los mandatos internos del tipo test, dando como resultado un valor de cierto o de falso. Suelen emplearse en operaciones condicionales y bucles, aunque también pueden ser empleadas en órdenes compuestas.

Podemos dividir las expresiones condicionales en varios tipos según el tipo de parámetros o su modo de operación:

Expresiones con ficheros: que comprueba la existencia, el tipo, los permisos o la facha de archivos o directorios.

Expresiones comparativas numéricas que evalúan la relación de orden numérico entre los parámetros.

Expresiones comparativas de cadenas que establecen la relación de orden alfabético entre los parámetros.

a) Expresiones de ficheros.

Son expresiones condicionales que devuelven el valor de cierto si se cumple la condición especificada; en caso contrario da un valor de falso. Hay una gran variedad de expresiones relacionadas con fichero

lista de expresiones

-e Fich: El fichero existe
-s Fich: El fichero esta vacío
-f Fich: Es un Fichero Normal
-d Fich: Es un directorio
-b Fich: Es un dispositivo de bloques
-c Fich: Es un dispositivo de caracteres
-p Fich: Es una tubería
-h Fich:
-L Fich: Es un enlace simbólico
-S Fich: Es un socket de comunicaciones.
-t Fich: El descriptor esta asociado a una terminal
Fich1 -ef Fich2: Los dos ficheros son enlaces hacia el mismo archivo

La siguiente lista de condiciones de permiso comprueban si el usuario que realiza la comprobación puede ejecutar la operación deseada sobre determinado fichero.

-r Fich: Permiso de lectura
-w Fich: Permiso de escritura
-x Fich: Permiso de ejecución
-u Fich: Permiso SUID
-g Fich: Permiso SGID
-t Fich: Permiso de directorio compartido o fichero en cache
-O Fich: es el propietario del archivo
-G Fich: El usuario pertenece al grupo con el GID del fichero

Ahora los operadores relacionados a las fechas

-N Fich: El fichero ha sido modificado desde la ultima lectura
Fich1 -nt Fich2: El Fich1 es mas nuevo que el Fich2
Fich1 -ot Fich2: El Fich1 es mas antiguo que el Fich2

b) Expresiones comparativas numéricas:

Aunque ya vimos los operadores de comparación numérica con las expresiones aritméticas a continuación daremos una lista de operadores ara este formato.

N1 -eq N2: Igual
N1 -ne N2: Diferente
N1 -lt N2: Menor que
N1 -gt N2: Mayor que

c) Expresiones comparativas de cadenas:

A continuación los formatos

Cad1 = Cad2: Igual
Cad1 != Cad2: Diferente
[-n] Cad: La cadena no esta vacía, su longitud no es 0
-z Cad: La longitud de la cadena es 0

El uso de estos los operadores condicionales los veremos más adelante en esta serie de tutoriales por ahora los dejamos en teoría teniendo en cuenta que es importante conocer detalles de este tipo pues aveces sucede que saltamos de variables a funciones y cuando venimos a ver no sabemos ni como hacer una suma y toca regresar.

Espero que les sea útil

Shell Script; Las Variables

 Introducción

Como vimos en la entrada anterior de, Shell Script Básico, un Script es un archivo que contiene una serie de comandos que son ejecutados secuencialmente por un interprete.

Aprendimos como crearlos, editarlos y ejecutarlos, además de que en un shell script podemos incluir los comandos básicos de Linux.

En esta ocasión continuaremos con algunos puntos más avanzados en la programación de scripts.

Las Variables.

Para los que no conocen de programación, veamos que es una variable: Las variables son espacios reservados en la memoria que, como su nombre indica, pueden cambiar de contenido a lo largo de la ejecución de un programa. De la siguiente manera le damos un valor a una variable:

nombre_variable=valor]

Sencillo no? También podemos guardar salidas de programas:

nombre_variable=`comando`
o
nombre_variable=$(comando)

Ejemplo:

variable=$(ls)

Al llamar la variable nos dará una lista de archivos y directorios de la ruta en l que nos encontramos.

También podemos asignarles valor a las variables con el comando (read).

read [ opciones] nombre_variable2 nombre_variableN

Ejemplo:

read -p "Introduce el Nombre y la edad" nombre edad

Las opciones mas usadas son:

-n num_car : Numero máximo de caracteres que se pueden introducir
-p "frase" : Muestra en la pantalla una frase
-d "delimitador" : Especifica un delimitador. Por ejemplo: si el delimitador es un ";" todo lo que este antes del signo lo tomara una variable y lo que este después en la siguiente variable.

Para utilizar los valores de una variable en el código lo hacemos así:

$nombre_variable

y para mostrarla:

echo $nombre_variable

Vamos a ver unos ejemplos sencillos que de una vez nos ayuden a repasar el post anterior.


#! /bin/bash
mkdir ~/Escritorio/Ejemlpo/
> ~/Escritorio/Ejemplo/ejemplo.txt
clear
read -p "Por favor Ingresa tu nombre y tu apellido " nombre apellido
saludo="Hola"
echo $saludo $nombre $apellido > ~/Escritorio/Ejemplo/ejemplo.txt
gedit ~/Escritorio/Ejemplo/ejemplo.txt &

Explicación:

1) Creamos un directorio llamado Ejemplo en el escritorio

2) Creamos un archivo ejemplo.txt dentro del directorio que recién creamos

3) Con el comando clear, Limpiamos la pantalla del terminal

4) le pedimos al usuario que ingrese su nombre y su apellido los cuales serán guardados en las variables nombre y apellido respectivamente

5) Guardamos la cadena "Hola" en la variable saludo

6) Imprimimos las variables $salud $nombre y $apellido en el archivo que creamos en el directorio Ejemplo

7) Por ultimo abrimos el archivo ejemplo.txt con gedit

A continuación un script que se me ocurrió el cual podría resultar útil para los diseñadores web para crear estructuras básicas para paginas web de ejemplos o cosas por el estilo con solo ejecutar un script


#! /bin/bash
clear
read -p "Por favor Ingresa el nombre del directorio raíz de tu pagina " dir
read -p "Por favor Ingresa el titulo tu pagina " titulo
read -p "Por favor Ingresa el nombre de tu pagina " nombreapp
read -p "Por favor Ingresa los tags de tu pagina " tags
read -p "Por favor Ingresa la descripción de tu pagina " descripcion
read -p "Por favor Ingresa el nombre el autor de tu pagina " autor
mkdir /var/www/$dir/;mkdir /var/www/$dir/js;mkdir /var/www/$dir/css;
mkdir /var/www/$dir/img
> /var/www/$dir/index.html; > /var/www/$dir/css/style.css
(
    echo '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">'
    echo '<html xmlns="http://www.w3.org/1999/xhtml" lang="es">'
    echo '    <head>'
    echo "        <title>$titulo</title>"
    echo '        <meta name="application-name" content="'$nombreapp'" />'
    echo '        <meta name="keywords" content="'$tags'" />'
    echo '        <meta name="description" content="'$descripcion'" />'
    echo '        <meta name="author" content="'$autor'" />'
    echo '        <meta http-equiv="content-type" content="text/html; charset=utf-8" />'
    echo '        <link href="css/style.css" rel="stylesheet" type="text/css" media="screen" />'
    echo '        <script type="text/javascript">'
    echo '        </script>'
    echo '    </head>'
    echo '    <body>'
    echo '    </body>'
    echo '</html>'
) > /var/www/$dir/index.html
firefox /var/www/$dir/index.html &
gedit /var/www/$dir/index.html &

Explicación:

1) Limpiamos la pantalla del terminal

2) Le pedimos al usuario ciertos datos necesarios y los guardamos en variables:

dir: Nombre del directorio raíz de la pagina
titulo: Titulo de la pagina
nombreapp, tags, descripcion y autor: para los meta datos application-name, keywords, description y author

3) Creamos el directorio raíz como vemos en el código el nombre del directorio es el valor de la variable $dir. Dentro de este directorio crearemos los directorios css, js e img

4) Creamos los archivos index.html y style.css dentro del directorio raíz y el directorio css respectivamente

5) Definimos lo que sera el contenido del documento, como podemos ver en el código todos los echo están encerrados en paréntesis y se les dice que se harán dentro del archivo index.html. Con esto logramos que se escriba dentro del archivo en el orden en que aparecen en el script.

6) por ultimo abrimos la pagina en el navegador, en mi caso firefox y en el editor de texto gedit listo para ser editado.

Como siempre espero que les sea de gran utilidad.

Shell Script Básico

Antes de Adentrarnos en el mundo de los scripts es necesario conocer ciertos conceptos básicos que nos ayudaran a entender de una mejor forma que es lo que estamos haciendo.

Que es un Script?

Un script es un tipo de programación interpretada que debido a su facilidad y funcionalidad, se imponen cada día más en el mundo de la informática. Los scripts son generalmente desarrollados en con lenguajes de relativa facilidad pero eso no quiere decir que sean menos funcionales que programas creados con lenguajes de alto nivel.

Trabajando con Linux

El sistema operativo Linux esconde tras de si una larga lista de utilidades que se ejecutan a través de comandos bastante complicados y con muchos parámetros y argumentos. Lo que hace el script es recoger todos esos comando y presentarlos al usuario de una forma sencilla y de rápido acceso.

Que es Shell?

El shell es un programa que sirve como puente de comunicación entre el usuario y el sistema operativo, es equivalente al MSDOS pero mucho más potente.

El shell sirve como interprete de comandos recibiendo los mismos y encargándose de su ejecución; bien sean comandos internos del sistema operativo o escrito por los usuarios en forma de scripts. En el primero de los casos es el mismo shell quien se encarga de la ejecución y en el segundo el shell da paso al kernell y es este quien ejecuta y procesa las ordenes.

El shell también sirve como interprete de programación presentando las mismas características de un lenguaje de programación de alto nivel.

Que necesitamos para comenzar.

Para hacerlo de manera ordenada Vamos a crear una carpeta para guardar nuestros scripts y en ella crearemos nuestro primer script. Abrimos la terminal y ponemos lo siguiente:

Creamos la carpeta

mkdir script

Donde mkdir (make directory) es el comando para crear carpetas o directorios y script es el nombre que le pondremos a nuestro directorio.

Entramos a la carpeta

cd script/

Donde cd (changue directory) es el comando para cambiar de directorio y script es el nombre que le colocamos a nuestra carpeta.
creamos un archivo con extensión .sh que contendrá al

touch archivo.sh

Donde touch es el comando para crear archivos y script.sh es nuestro archivo con extensión .sh

Le damos permisos de ejecución al archivo

sudo chmod 777 script.sh

Donde sudo (super User do) sirve para acceder como super usuario, chmod (change mod) es para cambiar los permisos, 777 indica que todos los usuarios tendrán todos los permisos y script.sh es el archivo al que le daremos los permisos.

Luego al presionar Enter nos pedirá la contraseña de súper usuario, la ingresamos.

Comprobamos los permisos del archivo

ls -l script.sh

donde ls (list) nos muestra una lista y con la opción -l muestra información de permisos, número de enlaces asociados al archivo, usuario, grupo, tamaño y fecha de última modificación además del nombre y script.sh es el script al que le dimos permiso.

Nos debería aparecer algo como esto



Por ultimo abrimos nuestro archivo para comenzar a editarlo. Para ello podemos utilizar cualquier editor de texto de nuestra preferencia , en este caso usaremos gedit

gedit script.sh &

Donde gedit le indica al bash que ejecute el editor sobre el archivo script.sh y el símbolo & nos permite seguir utilizando la terminal así se halla ejecutado el editor desde ella.

Hola Mundo

#! /bin/bash
#Script de Hola Mundo
clear
echo “Hola Mundo”

Explicación del código.

1) El carácter #! se llama Sha Bang y esta en la linea que inicia un script y sirve para indicarle al sistema que lo que viene a continuación es una secuencia de códigos a ser interpretados, en otras palabras, se trata de un numero mágico de dos bytes que es un marcador especial para determinar el tipo de archivo, en este caso, indica que se trata de un script de shell ejecutable.

2) El carácter # indica que lo que viene a continuación es un comentario.. los comentarios sirven para guiarnos a través del código.


3) El comando clear limpia la pantalla de nuestro terminal


4) el comando interno echo es una de las instrucciones más simples de la shell. Se encarga de repetir o desplegar en la salida estándar cualquier argumento que se le indique (inclusive comodines), para posteriormente saltar una línea. En pocas palabras nos muestra en la pantalla de nuestro terminal el mensaje Hola Mundo.


Ejecutando el Script

Ahora bien, ya tenemos listo nuestro script ¿pero como demonios lo ejecutamos? Muy sencillo, escribimos en la terminal lo siguiente:

sh script.sh

Otra manera seria

,/script.sh

Nota: Para que el script se ejecute correctamente es necesario que tenga permisos de ejecución.

Hola Mundo en un Archivo de Texto

#! /bin/bash
#Script que crea un archivo y le agrega la cadena Hola Mundo
> ~/Escritorio/archivo.txt
echo “Hola Mundo” > ~/Escritorio/archivo.txt
gedit archivo.txt &

Explicación

1) como ya vimos las dos primeras lineas son el llamado al interprete y un comentario, la tercera nos dice que cree un archivo llamado archivo.txt en el escritorio, el símbolo > es equivalente a touch, osea, sirve para crear un archivo el símbolo ~ es equivalente a la ruta /home/carpeta_personal/, es decir, en la carpeta personal entonces la ruta absoluta de nuestro archivo en este caso es /home/carpeta_personal/Escritorio/archivo.txt

2) La siguiente Linea Imprime la cadena Hola Mundo pero esta vez la imprime dentro de archivo.txt usando >


3) La ultima linea abre el archivo en el editor de texto gedit.


Con este sencillo tutorial tenemos una base para la creación de scripts mas complejos. Todo es cuestión de practica. Espero les sirva de algo.