Shell Scripting Parte V: Funciones en Bash

¡Hola! Bienvenido a la serie de tutoriales sobre scripting en shell de HowToForge. Si deseas leer las entregas anteriores del tutorial, siéntete libre de hacer clic aquí para la parte1, parte2, parte3 y parte4 del tutorial. En esta parte, aprenderás a estructurar eficientemente tus scripts creando funciones. Al final de este tutorial, podrás saber cómo crear funciones en el Shell de Linux Bash, pasar parámetros a tus funciones y devolver algunos valores de una función a tu código principal. ¡Comencemos!

Introducción

Una función, también conocida como subrutina en lenguajes de programación, es un conjunto de instrucciones que realiza una tarea específica para una rutina principal [1]. Permite a los programadores dividir un código complicado y extenso en secciones pequeñas que pueden ser llamadas cuando sea necesario. Cada función necesita ser llamada por una rutina principal para ejecutarse, por lo tanto, está aislada de otras partes de tu código y esto crea una forma fácil de probar el código. Además, las funciones pueden ser llamadas en cualquier momento y repetidamente, lo que te permite reutilizar, optimizar y minimizar tu código. Al igual que la mayoría de los lenguajes de programación, el shell bash también admite funciones.

Sintaxis General:

1. Sintaxis 1: function function_name { ##### conjunto de comandos }
2. Sintaxis 2: function_name() { #### conjunto de comandos }

Creando Funciones

El bash admite dos estructuras para funciones. Al usar la primera sintaxis, debes usar la palabra clave function, seguida de tu nombre de función y paréntesis abiertos y cerrados y llaves para separar el contenido de tus funciones de tu rutina principal. Encontrarás esta sintaxis familiar si tienes un trasfondo en PHP porque las funciones en PHP se declaran de la misma manera. La otra sintaxis consiste únicamente en un nombre de función, paréntesis abiertos y cerrados y llaves.

#!/bin/bash  
myfunction(){  
    echo "¡Mi función funciona!"  
}  
myfunction

He utilizado la segunda sintaxis en nuestro ejemplo. Después de crear la función myfunction, fue invocada llamando su nombre de función a nuestra rutina principal. La rutina principal estará en cualquier parte de nuestro script que no esté definida como parte de nuestra función.

Ahora reorganizamos nuestro código para probar si las funciones pueden ser declaradas en cualquier lugar de nuestro script. Considera el siguiente código:

#!/bin/bash  
echo "probando mi función"  
myfunction  
  
myfunction(){  
    echo "¡Mi función funciona!"  
}

La línea 3 en el código anterior devuelve un error de comando no encontrado. Esto solo significa que:

La función solo funciona si se declara antes de tu rutina principal. El intérprete devolverá un error si has declarado tu función después de tu rutina principal.

Reestructurando códigos usando funciones

Una de las mejores características de las funciones es poder reutilizar códigos. Cuando un procedimiento requiere ejecutar comandos repetidamente pero no se puede estructurar utilizando declaraciones de bucle, entonces una función puede ser una solución.

Por ejemplo, considera el siguiente código:

#!/bin/bash  
while(true)  
do  
    clear  
    printf "Elige entre las siguientes operaciones: \n"  
    printf "[a]dición\n[b]Sustracción\n[c]Multiplicación\n[d]División\n"  
    printf "################################\n"  
    read -p "Tu elección: " choice  
    case $choice in  
    [aA])  
        read -p "Ingresa el primer entero: " int1  
        read -p "Ingresa el segundo entero: " int2  
        res=$((int1+int2))  
  
    ;;  
    [bB])  
        read -p "Ingresa el primer entero: " int1  
        read -p "Ingresa el segundo entero: " int2  
    res=$((int1-int2))  
  
    ;;  
    [cC])  
        read -p "Ingresa el primer entero: " int1  
        read -p "Ingresa el segundo entero: " int2  
        res=$((int1*int2))  
  
    ;;  
    [dD])  
        read -p "Ingresa el primer entero: " int1  
        read -p "Ingresa el segundo entero: " int2  
        res=$((int1/int2))  
  
    ;;  
    *)  
        res=0  
        echo "¡Elección incorrecta!"  
    esac  
  
    echo "El resultado es: " $res  
    read -p "¿Deseas continuar? [s]í o [n]o: " ans  
    if [ $ans == 'n' ]  
        then  
         echo "Saliendo del script. ¡Que tengas un buen día!"  
        break  
    else  
        continue  
    fi  
  
done

El script está funcionando bien, sin embargo, nota que las líneas para aceptar entradas se repiten en cada patrón en nuestra declaración switch.

#!/bin/bash  
inputs(){  
     read -p "Ingresa el primer entero: " int1  
    read -p "Ingresa el segundo entero: " int2  
}  
  
exitPrompt(){  
    read -p "¿Deseas continuar? [s]í o [n]o: " ans  
    if [ $ans == 'n' ]  
    then  
        echo "Saliendo del script. ¡Que tengas un buen día!"  
        break  
    else  
        continue  
    fi  
}  
  
while(true)  
do  
    clear  
    printf "Elige entre las siguientes operaciones: \n"  
    printf "[a]Adición\n[b]Sustracción\n[c]Multiplicación\n[d]División\n"  
    printf "################################\n"  
    read -p "Tu elección: " choice  
  
    case $choice in  
    [aA])  
        inputs  
        res=$((int1+int2))  
    ;;  
  
    [bB])  
        inputs  
        res=$((int1-int2))  
    ;;  
  
    [cC])  
        inputs  
        res=$((int1*int2))  
    ;;  
  
    [dD])  
        inputs  
        res=$((int1/int2))  
    ;;  
  
    *)  
        res=0  
        echo "¡Elección incorrecta!"  
    esac  
  
    echo "El resultado es: " $res  
    exitPrompt  
done

Mejoramos nuestro código creando subsecciones inputs y exitPrompt. Funciona exactamente igual que nuestro código anterior, sin embargo, nuestro código actual es más fácil de depurar porque está estructurado correctamente.

Pasando parámetros a funciones

Al igual que la mayoría de los lenguajes de programación, puedes pasar parámetros y procesar esos datos en funciones en bash. El siguiente código muestra el procedimiento sobre cómo pasar valores en scripting de shell:

#!/bin/bash  
myfunction(){  
    echo $1  
    echo $2  
}  
  
myfunction "Hola" "Mundo"

Nota en nuestro ejemplo, añadimos los valores “Hola” y “Mundo” después de llamar a myfunction. Esos valores se pasan a myfunction como parámetros y se almacenan en una variable local. Sin embargo, a diferencia de otros lenguajes, el intérprete almacena los valores pasados en variables predefinidas, que se nombran de acuerdo con la secuencia de paso de los parámetros, 1 como el nombre inicial hasta el orden de paso. Nota que la palabra “Hola” se almacena en la variable 1 y el valor “Mundo” se almacena en la variable 2.

Nota: El 1 y 2 en nuestro ejemplo son variables locales y, por lo tanto, no son accesibles a otras partes del script aparte de la función donde se pasan los parámetros.

Por ejemplo,

#!/bin/bash  
myfunction(){  
    echo $1  
    echo $2  
}  
  
myfunction "Hola" "Mundo"  
echo $1  
echo $2

El echo $1 y echo $2 en las últimas dos líneas de nuestro script no tienen salida ya que el intérprete no reconoce ambas variables porque son locales a myfunction.

Devolviendo Valores de Funciones

Además de crear funciones y pasar parámetros a ellas, las funciones bash pueden pasar los valores de una variable local de función a la rutina principal utilizando la palabra clave return. Los valores devueltos se almacenan en la variable predeterminada $? Por ejemplo, considera el siguiente código:

#!/bin/bash  
add(){  
    sum=$(($1+$2))  
    return $sum  
}  
  
read -p "Ingresa un entero: " int1  
read -p "Ingresa un entero: " int2  
add $int1 $int2  
echo "El resultado es: " $?

En el ejemplo, pasamos los parámetros int1 e int2 a la función add. Luego, la función add los procesa a través de la línea sum=$(($1+$2)). Luego, el valor de la variable sum se pasa a la rutina principal a través de la línea return $sum. Por defecto, los valores de $sum se almacenarán en la variable predeterminada $? Finalmente, la línea echo “El resultado es: “ $? imprime el resultado.

Nota: Los scripts de shell solo pueden devolver un único valor.

A diferencia de otros lenguajes de programación, los scripts de shell no pueden devolver múltiples valores de una función. Veamos este ejemplo:

#!/bin/bash  
add(){  
    sum=$(($1+$2))  
    dif=$(($1-$2))  
    return $sum   
}  
  
read -p "Ingresa un entero: " int1  
read -p "Ingresa un entero: " int2  
add $int1 $int2  
echo "El resultado es: " $?  
echo "El resultado es: " $?

Para resumir

Tengamos otro ejemplo que utiliza funciones, pasa parámetros a ellas y devuelve un valor.

#!/bin/bash  
#####################  
#Autor: HowtoForge #  
#####################  
   
clear(){  
    clear  
}  
  
bin(){  
    bin1=$(echo "obase=2;$1"|bc)  
    echo $bin1  
}  
  
dec(){  
    dec1=$(echo "ibase=2;$1"|bc)  
    return $dec1  
}  
  
########Main#########  
    printf "Elige entre las siguientes operaciones:\n[1]Conversión de Decimal a Binario\n"  
    printf "[2]Conversión de Binario a Decimal\n"  
    read -p "Tu elección: " op  
    case $op in  
  
    1)  
        read -p "Ingresa un número entero: " int  
        bin $int  
    ;;  
  
    2)  
        read -p "Ingresa un número binario: " int  
        dec $int  
        echo "El equivalente decimal de $int es $?"  
    ;;  
  
    *)  
        echo "¡Elección Incorrecta!"  
    esac

El ejemplo dado convierte una entrada dada a valor binario o decimal utilizando el comando obase e ibase. La línea $(echo “obase=2;$1”|bc) convierte un valor decimal dado a dígito binario y lo almacena en la variable bin1. A continuación, mostramos el valor de $bin1 utilizando el comando echo.

Nota: Es mejor usar echo directamente al convertir de decimal a binario porque cuando devuelves un comando para pasar un valor binario, el bash convierte el valor binario a decimal antes de devolverlo.

Además, hemos convertido el valor binario a decimal utilizando el comando $(echo “ibase=2;$1”|bc).

También debes recordar que el intérprete solo es capaz de aceptar dígitos binarios de 8 bits. Si ingresas un dígito que excede el límite de 8 bits, generará un desbordamiento y el bit más significativo del dígito será descartado.

El dígito binario de 10 bits 1000001010 devuelve 10 ya que siguiendo la regla de 8 bits, los 2 bits restantes en el lado derecho (bit más significativo) serán omitidos, por lo tanto, 1000001010 se convertirá en 00001010 que es igual a 10. Si deseas una operación que acepte dígitos binarios que excedan los 8 bits, entonces debes crear el código manualmente.

Conclusión

Bash tiene funcionalidades que son muy similares a los lenguajes de programación para proporcionar numerosas herramientas al usuario y hacer que los sistemas Linux sean más potentes. En esta serie, has mejorado tu conocimiento en scripting de shell a través de funciones. Las funciones en scripts de shell proporcionan modularidad al usuario, haciendo que los scripts sean más fáciles de depurar y habilitando la reutilización de código.

Referencia:

[1] American Heritage® Dictionary of the English Language, Fifth Edition. Copyright © 2011 by Houghton Mifflin Harcourt Publishing Company. Published by Houghton Mifflin Harcourt Publishing Company.