Funciones de Shell

Introducción

En esta práctica de laboratorio, exploraremos las funciones de shell en Linux. Las funciones de shell son bloques de código reutilizables que realizan tareas específicas, lo que hace que nuestros scripts sean más organizados y eficientes. Aprenderemos a crear, llamar y utilizar funciones con parámetros en scripts de shell. Esta práctica está diseñada para principiantes, por lo que avanzaremos paso a paso y explicaremos cada concepto a fondo.

Creación de tu primera función de Shell

Comencemos creando una función de shell sencilla. Las funciones de shell son como mini-scripts dentro de un script más grande, lo que permite agrupar comandos que realizan una tarea específica.

Primero, necesitamos crear un archivo nuevo. Abre tu terminal y escribe:

cd ~/project
touch functions.sh

Este comando cambia al directorio project y crea un nuevo archivo llamado functions.sh. Este archivo contendrá nuestras funciones de shell.

Ahora, añadamos nuestra primera función:

#!/bin/bash

## This is a simple function
greet() {
  echo "Hello, World!"
}

## This line calls (runs) the function
greet

Analicemos esto:

• La primera línea #!/bin/bash se llama shebang. Indica al sistema que use bash para interpretar este script.
• Definimos nuestra función con greet() { }. Todo lo que esté entre las llaves forma parte de la función.
• Dentro de la función, tenemos un comando echo simple que imprime "Hello, World!".
• La última línea greet llama (ejecuta) nuestra función.

Ahora, hagamos que nuestro script sea ejecutable y ejecutémoslo:

chmod +x functions.sh
./functions.sh

Deberías ver:

Hello, World!

Si no ves este resultado, verifica que hayas escrito todo correctamente en el archivo functions.sh.

Funciones con parámetros

Ahora que hemos creado una función básica, vamos a hacerla más flexible añadiendo parámetros. Los parámetros nos permiten pasar información a nuestras funciones.

Abre de nuevo el archivo functions.sh y reemplaza el contenido con el siguiente código:

#!/bin/bash

## Function with a parameter
greet() {
  echo "Hello, $1!"
}

## Function with multiple parameters
calculate() {
  echo "The sum of $1 and $2 is $(($1 + $2))"
}

## Call functions with arguments
greet "Alice"
calculate 5 3

Examinemos este código:

• En la función greet, $1 se refiere al primer argumento pasado a la función.
• En la función calculate, $1 y $2 se refieren al primer y segundo argumento, respectivamente.
• $(($1 + $2)) realiza la suma aritmética de los dos parámetros.

Ejecuta el script:

./functions.sh

Deberías ver:

Hello, Alice!
The sum of 5 and 3 is 8

Si no ves este resultado, asegúrate de haber guardado los cambios en el archivo correctamente.

Valores de retorno de las funciones

En el scripting de shell, las funciones no devuelven valores de la misma manera que en otros lenguajes de programación. En su lugar, pueden imprimir un resultado que puede ser capturado, o pueden modificar una variable global. Exploremos ambos métodos.

Abre functions.sh de nuevo y actualiza el contenido con el siguiente código:

#!/bin/bash

## Function that echoes a result
get_square() {
  echo $(($1 * $1))
}

## Function that modifies a global variable
RESULT=0
set_global_result() {
  RESULT=$(($1 * $1))
}

## Capture the echoed result
square_of_5=$(get_square 5)
echo "The square of 5 is $square_of_5"

## Use the function to modify the global variable
set_global_result 6
echo "The square of 6 is $RESULT"

Analicemos esto:

• La función get_square utiliza echo para mostrar el resultado, el cual capturamos usando la sintaxis $().
• La función set_global_result modifica la variable global RESULT.
• Usamos $() para capturar la salida de get_square en una variable.
• Llamamos a set_global_result, que modifica RESULT, y luego imprimimos RESULT.

Guarda el archivo y ejecútalo:

./functions.sh

Deberías ver:

The square of 5 is 25
The square of 6 is 36

Si no ves este resultado, revisa tu archivo functions.sh en busca de errores tipográficos.

Entendiendo el alcance de las variables

En los scripts de shell, las variables son globales por defecto. Esto significa que se puede acceder a ellas desde cualquier lugar del script. Sin embargo, puedes usar la palabra clave local para crear variables que solo sean accesibles dentro de una función. Esto se conoce como alcance local.

Modifiquemos nuestro archivo functions.sh para demostrar este concepto.

Actualiza el contenido con el siguiente código:

#!/bin/bash

## Global variable
GLOBAL_VAR="I'm global"

## Function with a local variable
demonstrate_scope() {
  local LOCAL_VAR="I'm local"
  echo "Inside function: GLOBAL_VAR = $GLOBAL_VAR"
  echo "Inside function: LOCAL_VAR = $LOCAL_VAR"
}

## Call the function
demonstrate_scope

echo "Outside function: GLOBAL_VAR = $GLOBAL_VAR"
echo "Outside function: LOCAL_VAR = $LOCAL_VAR"

Esto es lo que sucede en este script:

• Definimos una variable global GLOBAL_VAR.
• Dentro de la función demonstrate_scope, definimos una variable local LOCAL_VAR usando la palabra clave local.
• Imprimimos ambas variables dentro de la función.
• Después de llamar a la función, intentamos imprimir ambas variables de nuevo fuera de ella.

Guarda el archivo y ejecútalo:

./functions.sh

Deberías ver una salida similar a esta:

Inside function: GLOBAL_VAR = I'm global
Inside function: LOCAL_VAR = I'm local
Outside function: GLOBAL_VAR = I'm global
Outside function: LOCAL_VAR =

Observa que LOCAL_VAR está vacía cuando se accede a ella fuera de la función. Esto se debe a que las variables locales solo son accesibles dentro de la función donde se definen.

Función avanzada - ENGLISH_CALC

Ahora que hemos cubierto los conceptos básicos de las funciones de shell, vamos a crear una función más avanzada llamada ENGLISH_CALC. Esta función recibirá tres argumentos: dos números y una operación (plus, minus o times).

Reemplaza el contenido con el siguiente código:

#!/bin/bash

ENGLISH_CALC() {
  local num1=$1
  local operation=$2
  local num2=$3
  local result

  case $operation in
    plus)
      result=$((num1 + num2))
      echo "$num1 + $num2 = $result"
      ;;
    minus)
      result=$((num1 - num2))
      echo "$num1 - $num2 = $result"
      ;;
    times)
      result=$((num1 * num2))
      echo "$num1 * $num2 = $result"
      ;;
    *)
      echo "Invalid operation. Please use 'plus', 'minus', or 'times'."
      return 1
      ;;
  esac
}

## Test the function
ENGLISH_CALC 3 plus 5
ENGLISH_CALC 5 minus 1
ENGLISH_CALC 4 times 6
ENGLISH_CALC 2 divide 2 ## This should show an error message

Desglosemos esta función:

• Usamos variables local para almacenar nuestras entradas y resultados. Esta es una buena práctica para evitar interferir con cualquier variable global.
• Usamos una sentencia case para manejar diferentes operaciones. Esto es similar a una sentencia switch en otros lenguajes.
• Para cada operación válida, realizamos el cálculo e imprimimos el resultado.
• Si se proporciona una operación no válida, imprimimos un mensaje de error y devolvemos 1 (en los scripts de shell, un valor de retorno distinto de cero indica un error).
• Al final, probamos nuestra función con varias entradas, incluyendo una operación no válida.

Guarda el archivo y ejecútalo:

./functions.sh

Deberías ver la siguiente salida:

3 + 5 = 8
5 - 1 = 4
4 * 6 = 24
Invalid operation. Please use 'plus', 'minus', or 'times'.

Si no ves este resultado, revisa tu archivo functions.sh en busca de errores tipográficos.

Resumen

En esta práctica de laboratorio, exploramos las funciones de shell en Linux, comenzando desde lo más básico y progresando hacia conceptos más avanzados. Aprendimos a:

1. Crear y llamar funciones simples.
2. Trabajar con parámetros de función.
3. Devolver valores de funciones usando echo y variables globales.
4. Comprender el alcance de las variables y usar variables locales.
5. Crear una función más compleja que procesa operaciones aritméticas.

Las funciones de shell son herramientas poderosas que pueden ayudarte a escribir código más organizado, eficiente y reutilizable. Te permiten dividir scripts complejos en piezas más pequeñas y manejables, haciendo que tus scripts sean más fáciles de entender y mantener.

Al dominar las funciones de shell, podrás escribir scripts de shell más sofisticados y automatizar tareas complejas de manera más efectiva en un entorno Linux. Recuerda, la práctica es clave para volverse competente en el scripting de shell. Intenta modificar las funciones que hemos creado o crea las tuyas propias para resolver problemas específicos que encuentres en tu trabajo con Linux.