Si en un shell script queremos comprobar cualquier cosa y, que el script actúe de manera distinta según el resultado de la comprobación usaremos:

if [ condición ]
then
     # instrucciones a ejecutar si la condición es cierta
fi

O si queremos que en caso de que la condición sea falsa ejecute otras instrucciones:

if [ condición ]
then
     # instrucciones a ejecutar si la condición es cierta
else
     # instrucciones a ejecutar en caso de que la condición sea falsa
fi

Y si queremos que vuelva a hacer una comprobación, en caso de que la condición sea cierta o falsa, usaremos:

if [ condición ]
then
     # instrucciones a ejecutar si la condición es cierta
elif [ condición ]
then
     # instrucciones a ejecutar si la segunda comprobación es cierta
else 
     # instrucciones a ejecutar si las dos comprobaciones anteriores son falsas
fi

Y podemos incluir tantos if dentro de otros if como queramos. 

Para la temática que nos ocupa en este tutorial, comprobaremos:
Si un determinado directorio existe con [ -d $directorio ]
En caso de que queramos comprobar si el directorio no existe, se niega la condición con un signo de exclamación: [ ! -d $directorio ]
Si el directorio tiene algún fichero o directorio [ "$(ls $directorio)" ]
O si el directorio está vacío [ ! "$(ls $directorio)" ]

Vistas las aclaraciones, el código que comprueba si un directorio existe o no y que, en caso de que exista, compruebe si está vacío o no, sería:

if [ ! -d $directorio ]
then
     echo "El directorio no existe"
else 
     if [ "$(ls $directorio)" ]
     then 
         echo "el directorio tiene algo"
     else
         echo "el directorio está vacío"
     fi
fi

Tanto en los scrips en Bash como en sus funciones, los parámetros nos ofrece la posibilidad de interactuar con ellos, pudiéndole enviar datos para que los procese o que el script actúe de una determinada manera según los parámetros enviados. Veamos cómo trabajar con ellos y cómo sacarles partido.

Trabajar con un parámetro concreto

Los parámetros se almacenan automáticamente en orden con un dólar delante del número que ocupan la posición que ocupan, empezando por 1, no por 0. Es decir, el primer parámetro de la función / script será $1; el segundo, $2... y así sucesivamente.

$0 se reserva para el nombre del script.

Ojo, en una función $0 es el nombre del script, pero $1 es el primer parámetro de la función, no del script.

#!/bin/bash
function saludo()
{
      echo "Soy una función que se llama $0 y saluda: Hola, "$1

}

textosaludo=$(saludo Pepe)
echo $textosaludo

Si no le pasamos parámetros, devuelve:

./funcionquesaluda.sh
Soy una función que se llama ./funcionquesaluda.sh y saluda: Hola, Pepe

Y si le pasamos parámetros, devuelve lo mismo:

./funcionquesaluda.sh Manolo
Soy una función que se llama ./funcionquesaluda.sh y saluda: Hola, Pepe


Trabajar con todos los parámetros

Si queremos conocer todos los parámetros, usaremos $* y para saber el número de parámetros, $#.

Así pues, el script:

#!/bin/bash
function saludo()
{
      echo "Soy una función que se llama" $0 "y saluda: Hola, "$1
      echo "He recibido "$# " parámetros, que son: "$*

}

textosaludo=$(saludo Pepe María Juan Marcos Manolo Marta)
echo $textosaludo

Devuelve:

./funcionquesaluda.sh Manolo
Soy una función que se llama ./funcionquesaluda.sh y saluda: Hola, Pepe He recibido 6 parámetros, que son: Pepe María Juan Marcos Manolo Marta

Y aquí vemos un nuevo concepto. Al escribir varios echo en una función, concatena las cadenas. Si quisiéramos que no lo hiciera, añadiríamos un retorno de carro:

#!/bin/bash
function saludo()
{
      echo "Soy una función que se llama" $0 "y saluda: Hola, "$1
      echo -e "\r"
      echo "He recibido "$# " parámetros, que son: "$*

}

textosaludo=$(saludo Pepe María Juan Marcos Manolo Marta)
echo $textosaludo

Nos devolvería:

./funcionquesaluda.sh Manolo
He recibido 6 parámetros, que son: Pepe María Juan Marcos Manolo Marta


Ya hemos visto cómo hacer funciones en shell script, cómo enviarle parámetros y ahora veremos cómo recoger en una variable el resultado del proceso de una función. 

Veamos el ejemplo de los artículos anteriores modificado para recibir el resultado de la función en una variable:

#!/bin/bash
function saludo()
{
      echo "Soy una función que saluda: Hola, "$1 
}
textosaludo=$(saludo Pepe)
echo $textosalud

Como vemos, al igual que una función procesa los parámetros como un script ($1 es el primer parámetro recibido), a la hora de invocar la función y recibir el resultado en una variable también la instrucción es igual que si fuera un comando más de la shell:

variable=$(comando parametro1 parametro2...)

Definiendo la variable sin dólar delante. Recibiendo el valor con un igual, e indicándole que esa variable va a tomar el valor del resultado de la función con dólar y el comando/función con sus parámetros entre paréntesis. 

Y no olvidemos que, aunque definamos las variables únicamente con el nombre, para trabar con el valor almacenado hay que escribir un dólar antes del nombre de la variable. 

Cuando hacemos funciones en shell script, el siguiente paso es poder interactuar con las funciones. Poder enviarle datos y que nos devuelva resultados. 

Una vez definida una función, esta actuará siempre como un si fuera un comando. Tanto internamente, que recogerá en $1 el parámetro le pasemos en primer lugar, $2, el parámetro que le pasemos en segundo lugar... como para pasarle parámetros a la hora de invocar la función, que lo haremos como si fuera el parámetro de un comando normal. 

Veamos un ejemplo:

#!/bin/bash
function saludo()
{
   echo "Soy una función que saluda: Hola, "$1 
}
saludo Pepe


Nos devolverá al ejecutar el script:

Soy una función que saluda: Hola, Pepe

Una de las principales ventajas de los sistemas derivados de Unix es la posibilidad de automatizar tareas. Para realizar las tareas repetitivas están los scripts, pero dentro de los scripts, puede que haya también tareas repetitivas. Y para hacer esas tarear repetitivas dentro de los scripts están las funciones. 

Declarar una función

Para programar una función dentro de un script, deberemos declararla con funtion nombredelafuncion() y el código entre corchetes. Así:

#!/bin/bash
function funcionquesaluda()
{
     echo "Hola, mundo, soy una función que saluda."
}


Invocar a una función

Esta función devolvería un texto. Pero para que se ejecute, deberemos invocarla como si fuera una instrucción más del script:

funcionquesaluda

Por lo que el script que define esta función y luego la invoca sería algo así:

#!/bin/bash
function funcionquesaluda()
{
     echo "Hola, mundo, soy una función que saluda."
}

echo "Soy un script que saluda: Hola, mundo"
funcionquesaluda


 Que nos devolverá esto:

Soy un script que saluda: Hola, mundo
Hola, mundo, soy una función que saluda.

 Ahora que ya sabemos hacer funciones, aprenderemos a enviar parámetros a las funciones. 

Os traigo esta curiosidad para aquellos que quieran saber que está reproduciendo vuestro reproductor favorito, se trata de un simple script que hace uso de dbus para extraer los datos necesarios, a saber, artista, titulo y album y mostrarlos a nivel de terminal o en un cuadro de dialogo.

Lo primero que debemos hacer es buscar con qdbus lo que está enviando el reproductor a traves de dbus. (He usado qdbus contenido en qt5-tools, en ArchLinux).

Para ello lanzamos una terminal y escribmos en ella lo siguiente (con el reproductor en marcha y reproduciendo):

qdbus | grep MediaPlayer2

y así nos saldría algo parecido a esto:

org.mpris.MediaPlayer2.cantata

Una vez identificado el reproductor, es cuestión de ir navegando por las ramas, se puede hacer con tab, ejemplo

qdbus org.mpris.MediaPlayer2.cantata <TAB>

y nos irá saliendo algo parecido a esto:

$ qdbus org.mpris.MediaPlayer2.cantata /MenuBar
/ /MenuBar/1 /org /org/mpris/MediaPlayer2
/MenuBar /cantata /org/mpris


Como cada reproductor puede ser diferente, es ir buscando concretamente la rama en la que está los campos artist, title y album.

Os dejo un ejemplo de un script que me hice a tal proposito para el reproductor Cantata, donde os podéis hacer una idea de como funciona.

#!/bin/sh
artista=`qdbus org.mpris.MediaPlayer2.cantata /org/mpris/MediaPlayer2 org.mpris.MediaPlayer2.Player.Metadata | grep xesam:artist | cut -b 14-`
titulo=`qdbus org.mpris.MediaPlayer2.cantata /org/mpris/MediaPlayer2 org.mpris.MediaPlayer2.Player.Metadata | grep xesam:title | cut -b 14-`
album=`qdbus org.mpris.MediaPlayer2.cantata /org/mpris/MediaPlayer2 org.mpris.MediaPlayer2.Player.Metadata | grep xesam:album: | cut -b 14-`

out="Ahora suena: $titulo de $artista del album $album"
echo $out
echo $out > /tmp/nowplaying
kdialog --textbox /tmp/nowplaying
#zenity --text-info --filename=/tmp/nowplaying

El primer bloque tenemos 3 variables, artista, titulo y album, los cuales van a almacenar lo recogido por qdbus. El segundo bloque lo vamos a hacer es crear otra variable, out, que va a conterner una cadena de texto con la información que quieras y con las otras tres variables anteriormente creadas y almacenadas. Al final, usamos la variable out para mostrar todo junto en dos partes, la primera lo muestra a nivel de terminal, la otra almacena en un fichero la salida de out y hacemos uso de kdialog o zenity mostrando su contenido.

Al final os mostrará lo que se está reproduciendo en vuestra terminal y si queréis un dialogo gráfico, podréis usar kdialog para KDE Plasma o Zenity para entornos GTK (Gnome, Xfce, etc...)

Espero que os haya gustado.