Valores de retorno de funciones en Bash

Introducción

Este tutorial completo explora los valores de retorno de las funciones en Bash, brindándote el conocimiento y las técnicas esenciales para trabajar de manera efectiva con funciones en los scripts de Bash. Ya seas nuevo en la programación de scripts de shell o estés buscando mejorar tus habilidades, esta guía te ofrece una comprensión sólida de cómo definir, llamar y manejar los valores de retorno de las funciones. Estas habilidades te permiten escribir scripts de shell más robustos y flexibles para diversas tareas de automatización.

Skills Graph

Creando tu primera función en Bash

Las funciones en Bash son bloques de código reutilizables que ayudan a organizar mejor tus scripts. Antes de profundizar en los valores de retorno, primero entendamos cómo crear y llamar a una función.

Creando una función básica

Vamos a crear nuestra primera función en Bash. Abre una ventana de terminal y escribe:

cd ~/project
mkdir -p bash_functions
cd bash_functions

Ahora vamos a crear una función simple en un nuevo script. Crea un archivo llamado first_function.sh usando nano:

touch first_function.sh

Agrega el siguiente contenido al archivo:

#!/bin/bash

## Define a simple greeting function
say_hello() {
  echo "Hello, world!"
}

## Call the function
say_hello

## Define a function that accepts arguments
greet_person() {
  echo "Hello, $1!"
}

## Call the function with an argument
greet_person "Alice"
greet_person "Bob"

Haz el script ejecutable:

chmod +x first_function.sh

Ahora ejecuta el script:

./first_function.sh

Deberías ver esta salida:

Hello, world!
Hello, Alice!
Hello, Bob!

Explicación de la sintaxis de las funciones

En Bash, hay dos formas de definir funciones:

1. Usando la sintaxis estándar:

function_name() {
  ## Commands
}

2. Usando la palabra clave function:

function function_name {
  ## Commands
}

Ambos estilos funcionan de la misma manera, pero el primero se usa más comúnmente y es compatible con POSIX.

Accediendo a los argumentos de una función

Dentro de una función, puedes acceder a los argumentos pasados a la función usando parámetros posicionales:

• $1, $2, $3, etc. se refieren al primer, segundo, tercer argumento, y así sucesivamente
• $0 se refiere al nombre de la función o al nombre del script
• $# da el número de argumentos
• $@ contiene todos los argumentos como cadenas separadas
• $* contiene todos los argumentos como una sola cadena

Vamos a crear un nuevo archivo para practicar con los argumentos de una función:

touch function_args.sh

Agrega el siguiente contenido:

#!/bin/bash

show_args() {
  echo "Function name: $0"
  echo "First argument: $1"
  echo "Second argument: $2"
  echo "Number of arguments: $#"
  echo "All arguments: $@"
}

echo "Calling function with three arguments:"
show_args apple banana cherry

Guarda, hazlo ejecutable y ejecuta el script:

chmod +x function_args.sh
./function_args.sh

Deberías ver una salida similar a:

Calling function with three arguments:
Function name: ./function_args.sh
First argument: apple
Second argument: banana
Number of arguments: 3
All arguments: apple banana cherry

Esta comprensión básica de las definiciones de funciones y el manejo de argumentos proporciona la base para trabajar con los valores de retorno de las funciones en los siguientes pasos.

Entendiendo los códigos de retorno de las funciones

Cada comando en Bash, incluyendo las funciones, produce un código de retorno (también llamado estado de salida). Este valor numérico indica si el comando se ejecutó con éxito o falló. Este código de retorno es fundamental para el manejo de errores en los scripts de Bash.

Códigos de retorno básicos

En Bash:

• Un código de retorno de 0 indica éxito
• Cualquier valor distinto de cero (1 - 255) indica un error o una condición anormal

Vamos a crear un script para demostrar esto:

cd ~/project/bash_functions
touch return_codes.sh

Agrega el siguiente contenido:

#!/bin/bash

## Function that always succeeds
succeed() {
  echo "This function succeeds"
  return 0
}

## Function that always fails
fail() {
  echo "This function fails"
  return 1
}

## Call the functions and check their return codes
succeed
echo "Return code of succeed: $?"

fail
echo "Return code of fail: $?"

Guarda, hazlo ejecutable y ejecuta el script:

chmod +x return_codes.sh
./return_codes.sh

Deberías ver:

This function succeeds
Return code of succeed: 0
This function fails
Return code of fail: 1

Capturando códigos de retorno

La variable especial $? contiene el código de retorno del comando o función ejecutado más recientemente. Este valor es importante para la ejecución condicional y el manejo de errores.

Vamos a crear otro script para practicar el uso de códigos de retorno para la lógica condicional:

touch check_file.sh

Agrega el siguiente contenido:

#!/bin/bash

## Function to check if a file exists
file_exists() {
  local filename="$1"

  if [ -f "$filename" ]; then
    echo "File $filename exists"
    return 0
  else
    echo "File $filename does not exist"
    return 1
  fi
}

## Test the function with files that exist and don't exist
file_exists "return_codes.sh"
if [ $? -eq 0 ]; then
  echo "Great! The file was found."
else
  echo "Too bad. The file was not found."
fi

echo ""

file_exists "non_existent_file.txt"
if [ $? -eq 0 ]; then
  echo "Great! The file was found."
else
  echo "Too bad. The file was not found."
fi

Guarda, hazlo ejecutable y ejecuta el script:

chmod +x check_file.sh
./check_file.sh

Deberías ver una salida similar a:

File return_codes.sh exists
Great! The file was found.

File non_existent_file.txt does not exist
Too bad. The file was not found.

Usando códigos de retorno en expresiones condicionales

El código de retorno se puede usar directamente en expresiones condicionales utilizando los operadores && (AND) y || (OR):

touch conditional_return.sh

Agrega el siguiente contenido:

#!/bin/bash

check_number() {
  local num=$1

  if [ $num -gt 10 ]; then
    return 0 ## Success if number is greater than 10
  else
    return 1 ## Failure if number is not greater than 10
  fi
}

## Using conditional operators with return codes
check_number 15 && echo "Number is greater than 10"
check_number 5 || echo "Number is not greater than 10"

## This line runs only if check_number succeeds
check_number 20 && {
  echo "Number is greater than 10"
  echo "Performing additional operations..."
}

## This line runs only if check_number fails
check_number 3 || {
  echo "Number is not greater than 10"
  echo "Taking alternative actions..."
}

Guarda, hazlo ejecutable y ejecuta el script:

chmod +x conditional_return.sh
./conditional_return.sh

La salida debería ser:

Number is greater than 10
Number is not greater than 10
Number is greater than 10
Performing additional operations...
Number is not greater than 10
Taking alternative actions...

Entender cómo funcionan los códigos de retorno es esencial para escribir scripts robustos que puedan manejar errores adecuadamente y tomar decisiones basadas en el éxito o fracaso de las operaciones.

Trabajando con valores de retorno personalizados

Si bien los códigos de retorno son útiles para indicar éxito o fracaso, se limitan a números entre 0 y 255. Para devolver datos reales desde las funciones, necesitamos utilizar otras técnicas.

Método 1: Usando Echo para devolver valores

La forma más común de devolver valores reales desde las funciones es utilizando echo u otros comandos de salida y luego capturar esa salida.

Vamos a crear un script para demostrar esta técnica:

cd ~/project/bash_functions
touch return_values.sh

Agrega el siguiente contenido:

#!/bin/bash

## Function that returns a value using echo
get_username() {
  echo "labex"
}

## Function that returns a calculated value
add_numbers() {
  local sum=$(($1 + $2))
  echo $sum
}

## Capture the returned values
username=$(get_username)
echo "The username is: $username"

result=$(add_numbers 5 7)
echo "The sum of 5 and 7 is: $result"

## You can also use the returned value directly
echo "Calculating again: $(add_numbers 10 20)"

Guarda, hazlo ejecutable y ejecuta el script:

chmod +x return_values.sh
./return_values.sh

Deberías ver:

The username is: labex
The sum of 5 and 7 is: 12
Calculating again: 30

Método 2: Usando variables globales

Otro enfoque es modificar variables globales dentro de la función:

touch global_return.sh

Agrega el siguiente contenido:

#!/bin/bash

## Declare global variables
FULL_NAME=""
USER_AGE=0

## Function that sets global variables
set_user_info() {
  FULL_NAME="$1 $2"
  USER_AGE=$3

  ## Return success
  return 0
}

## Call the function
set_user_info "John" "Doe" 30

## Use the global variables that were set by the function
echo "Full name: $FULL_NAME"
echo "Age: $USER_AGE"

Guarda, hazlo ejecutable y ejecuta el script:

chmod +x global_return.sh
./global_return.sh

Salida:

Full name: John Doe
Age: 30

Método 3: Devolviendo múltiples valores

Vamos a explorar cómo devolver múltiples valores desde una función:

touch multiple_returns.sh

Agrega el siguiente contenido:

#!/bin/bash

## Function that returns multiple values separated by a delimiter
get_system_info() {
  local hostname=$(hostname)
  local kernel=$(uname -r)
  local uptime=$(uptime -p)

  ## Return multiple values separated by semicolons
  echo "$hostname;$kernel;$uptime"
}

## Capture the output and split it
system_info=$(get_system_info)

## Split the values using IFS (Internal Field Separator)
IFS=';' read -r host kernel up <<< "$system_info"

## Display the values
echo "Hostname: $host"
echo "Kernel version: $kernel"
echo "Uptime: $up"

## Alternative method using an array
get_user_details() {
  local details=("John Doe" "john@example.com" "Developer")
  printf "%s\n" "${details[@]}"
}

## Capture the output into an array
mapfile -t user_details < <(get_user_details)

echo ""
echo "User information:"
echo "Name: ${user_details[0]}"
echo "Email: ${user_details[1]}"
echo "Role: ${user_details[2]}"

Guarda, hazlo ejecutable y ejecuta el script:

chmod +x multiple_returns.sh
./multiple_returns.sh

La salida debería mostrar la información de tu sistema seguida de los detalles del usuario:

Hostname: ubuntu
Kernel version: 5.15.0-1033-azure
Uptime: up 2 hours, 15 minutes

User information:
Name: John Doe
Email: john@example.com
Role: Developer

El nombre de host, la versión del kernel y el tiempo de actividad reales variarán según tu sistema.

Estos métodos demuestran diferentes formas de devolver valores desde las funciones más allá de los simples códigos de retorno. Cada enfoque tiene sus ventajas según tus necesidades específicas.

Uso práctico de funciones en un script

Ahora que entendemos cómo definir funciones y manejar sus valores de retorno, vamos a construir un script práctico que demuestre estos conceptos en acción. Crearemos una utilidad de gestión de archivos que utilice funciones con diferentes métodos de retorno.

Creando la utilidad de gestión de archivos

Vamos a crear un script completo que realice varias operaciones de archivos:

cd ~/project/bash_functions
touch file_manager.sh

Agrega el siguiente contenido:

#!/bin/bash

## Function to check if a file exists
## Returns 0 if file exists, 1 if it doesn't
file_exists() {
  if [ -f "$1" ]; then
    return 0
  else
    return 1
  fi
}

## Function to get file size in bytes
## Returns the size via echo
get_file_size() {
  if file_exists "$1"; then
    ## Use stat to get file size in bytes
    local size=$(stat -c %s "$1")
    echo "$size"
  else
    echo "0"
  fi
}

## Function to count lines in a file
## Returns line count via echo
count_lines() {
  if file_exists "$1"; then
    local lines=$(wc -l < "$1")
    echo "$lines"
  else
    echo "0"
  fi
}

## Function to get file information
## Returns multiple values using a delimiter
get_file_info() {
  local filename="$1"

  if file_exists "$filename"; then
    local size=$(get_file_size "$filename")
    local lines=$(count_lines "$filename")
    local modified=$(stat -c %y "$filename")
    local permissions=$(stat -c %A "$filename")

    ## Return all info with semicolons as delimiters
    echo "$size;$lines;$modified;$permissions"
  else
    echo "0;0;N/A;N/A"
  fi
}

## Function to create a test file
create_test_file() {
  local filename="$1"
  local lines="$2"

  ## Create or overwrite the file
  > "$filename"

  ## Add the specified number of lines
  for ((i = 1; i <= lines; i++)); do
    echo "This is line $i of the test file." >> "$filename"
  done

  ## Return success if file was created
  if file_exists "$filename"; then
    return 0
  else
    return 1
  fi
}

## Main script execution starts here
echo "File Management Utility"
echo "----------------------"

## Create a test file
TEST_FILE="sample.txt"
echo "Creating test file with 10 lines..."
if create_test_file "$TEST_FILE" 10; then
  echo "File created successfully."
else
  echo "Failed to create file."
  exit 1
fi

## Check if file exists
echo ""
echo "Checking if file exists..."
if file_exists "$TEST_FILE"; then
  echo "File '$TEST_FILE' exists."
else
  echo "File '$TEST_FILE' does not exist."
fi

## Get file size
echo ""
echo "Getting file size..."
size=$(get_file_size "$TEST_FILE")
echo "File size: $size bytes"

## Count lines
echo ""
echo "Counting lines in file..."
lines=$(count_lines "$TEST_FILE")
echo "Line count: $lines"

## Get all file information
echo ""
echo "Getting complete file information..."
file_info=$(get_file_info "$TEST_FILE")

## Split the returned values
IFS=';' read -r size lines modified permissions <<< "$file_info"

echo "File: $TEST_FILE"
echo "Size: $size bytes"
echo "Lines: $lines"
echo "Last modified: $modified"
echo "Permissions: $permissions"

echo ""
echo "File content preview:"
head -n 3 "$TEST_FILE"
echo "..."

Guarda, hazlo ejecutable y ejecuta el script:

chmod +x file_manager.sh
./file_manager.sh

Deberías ver una salida similar a:

File Management Utility
----------------------
Creating test file with 10 lines...
File created successfully.

Checking if file exists...
File 'sample.txt' exists.

Getting file size...
File size: 300 bytes

Counting lines in file...
Line count: 10

Getting complete file information...
File: sample.txt
Size: 300 bytes
Lines: 10
Last modified: 2023-11-04 12:34:56.789012345 +0000
Permissions: -rwxrwxr-x

File content preview:
This is line 1 of the test file.
This is line 2 of the test file.
This is line 3 of the test file.
...

Los valores exactos del tamaño del archivo, la hora de modificación y los permisos variarán.

Desglosando el script

Nuestra utilidad de gestión de archivos demuestra varios conceptos clave:

1. Códigos de retorno - Las funciones file_exists() y create_test_file() devuelven 0 para éxito y 1 para fracaso.
2. Devolver valores con echo - Las funciones get_file_size() y count_lines() devuelven valores numéricos a través de echo.
3. Devolver múltiples valores - La función get_file_info() devuelve múltiples valores utilizando un delimitador.
4. Composición de funciones - Algunas funciones llaman a otras funciones, lo que demuestra cómo construir funcionalidad compleja.
5. Ejecución condicional - El script utiliza sentencias if con códigos de retorno para controlar el flujo del programa.

Este ejemplo práctico muestra cómo combinar varias técnicas de funciones para crear una utilidad útil. El script demuestra un manejo adecuado de errores, composición de funciones y diferentes métodos para devolver valores.

Manejo de errores y mejores prácticas para funciones

En esta última sección, exploraremos técnicas de manejo de errores y mejores prácticas para las funciones en Bash. Un manejo adecuado de errores es crucial para crear scripts robustos y mantenibles.

Creando un script con manejo de errores

Vamos a crear un nuevo script que demuestre un manejo robusto de errores:

cd ~/project/bash_functions
touch error_handling.sh

Agrega el siguiente contenido:

#!/bin/bash

## Enable error handling
set -e ## Exit immediately if a command exits with non-zero status

## Define a function to log messages
log_message() {
  local level="$1"
  local message="$2"
  echo "[$(date '+%Y-%m-%d %H:%M:%S')] [$level] $message"
}

## Function to validate a number is positive
validate_positive() {
  local num="$1"
  local name="$2"

  ## Check if the argument is a number
  if ! [[ "$num" =~ ^[0-9]+$ ]]; then
    log_message "ERROR" "$name must be a number"
    return 1
  fi

  ## Check if the number is positive
  if [ "$num" -le 0 ]; then
    log_message "ERROR" "$name must be positive"
    return 2
  fi

  return 0
}

## Function that divides two numbers
divide() {
  local numerator="$1"
  local denominator="$2"

  ## Validate inputs
  validate_positive "$numerator" "Numerator" || return $?
  validate_positive "$denominator" "Denominator" || return $?

  ## Check for division by zero
  if [ "$denominator" -eq 0 ]; then
    log_message "ERROR" "Division by zero is not allowed"
    return 3
  fi

  ## Perform division
  local result=$(echo "scale=2; $numerator / $denominator" | bc)
  echo "$result"
  return 0
}

## Function to safely get user input
get_number() {
  local prompt="$1"
  local input

  while true; do
    read -p "$prompt: " input

    if validate_positive "$input" "Input"; then
      echo "$input"
      return 0
    else
      log_message "WARN" "Invalid input. Please try again."
    fi
  done
}

## Disable automatic exit on error for the main script
set +e

## Main script logic
log_message "INFO" "Starting division calculator"

## Test with valid values
result=$(divide 10 2)
exit_code=$?

if [ $exit_code -eq 0 ]; then
  log_message "INFO" "10 / 2 = $result"
else
  log_message "ERROR" "Division failed with code $exit_code"
fi

## Test with invalid values
echo ""
log_message "INFO" "Testing with invalid values"
divide 0 5
log_message "INFO" "Exit code: $?"

divide 10 0
log_message "INFO" "Exit code: $?"

divide abc 5
log_message "INFO" "Exit code: $?"

## Interactive mode
echo ""
log_message "INFO" "Interactive mode"
echo "Let's perform a division. Enter positive numbers."

## Get user input safely
num1=$(get_number "Enter first number")
num2=$(get_number "Enter second number")

## Perform division
result=$(divide "$num1" "$num2")
exit_code=$?

if [ $exit_code -eq 0 ]; then
  log_message "INFO" "$num1 / $num2 = $result"
else
  log_message "ERROR" "Division failed with code $exit_code"
fi

log_message "INFO" "Calculator finished"

Guarda, hazlo ejecutable y ejecuta el script:

chmod +x error_handling.sh
./error_handling.sh

Verás una salida similar a la siguiente y se te pedirá que ingreses números:

[2023-11-04 13:45:23] [INFO] Starting division calculator
[2023-11-04 13:45:23] [INFO] 10 / 2 = 5.00

[2023-11-04 13:45:23] [INFO] Testing with invalid values
[2023-11-04 13:45:23] [ERROR] Numerator must be positive
[2023-11-04 13:45:23] [INFO] Exit code: 2
[2023-11-04 13:45:23] [ERROR] Division by zero is not allowed
[2023-11-04 13:45:23] [INFO] Exit code: 3
[2023-11-04 13:45:23] [ERROR] Numerator must be a number
[2023-11-04 13:45:23] [INFO] Exit code: 1

[2023-11-04 13:45:23] [INFO] Interactive mode
Let's perform a division. Enter positive numbers.
Enter first number:

Ingresa un número, por ejemplo 20. Luego se te pedirá el segundo número:

Enter second number:

Ingresa otro número, por ejemplo 4, y deberías ver:

[2023-11-04 13:45:30] [INFO] 20 / 4 = 5.00
[2023-11-04 13:45:30] [INFO] Calculator finished

Mejores prácticas para funciones en Bash

Basándonos en nuestros ejemplos, aquí están algunas mejores prácticas para trabajar con funciones en Bash:

1. Agrega comentarios descriptivos - Documenta lo que hace cada función, sus parámetros y valores de retorno.
2. Usa nombres de función significativos - Elige nombres que indiquen claramente el propósito de la función.
3. Valida los parámetros de entrada - Verifica las entradas para prevenir errores.
4. Usa variables locales - Evita colisiones de nombres de variables con la palabra clave local.
5. Devuelve códigos de salida adecuados - Utiliza códigos de retorno convencionales (0 para éxito, distinto de cero para errores).
6. Implementa un manejo adecuado de errores - Registra los errores y manéjalos con gracia.
7. Mantén las funciones enfocadas - Cada función debe hacer una cosa bien.
8. Usa la composición de funciones - Construye funcionalidad compleja combinando funciones más simples.
9. Documenta los valores de retorno - Documenta claramente cómo se devuelven los valores (a través de echo, código de retorno, etc.).
10. Prueba los casos extremos - Asegúrate de que las funciones manejen correctamente entradas inusuales.

Siguiendo estas prácticas, puedes crear funciones en Bash más confiables, mantenibles y reutilizables.

Creando una biblioteca de funciones

Para el último ejercicio, vamos a crear una biblioteca de funciones reutilizable:

touch math_functions.lib

Agrega el siguiente contenido:

#!/bin/bash
## math_functions.lib - A library of mathematical functions

## Add two numbers
add() {
  echo $(($1 + $2))
}

## Subtract second number from first
subtract() {
  echo $(($1 - $2))
}

## Multiply two numbers
multiply() {
  echo $(($1 * $2))
}

## Divide first number by second (with decimal precision)
divide() {
  if [ "$2" -eq 0 ]; then
    return 1
  fi
  echo "scale=2; $1 / $2" | bc
  return 0
}

## Calculate power: first number raised to second number
power() {
  echo $(($1 ** $2))
}

## Check if a number is even
is_even() {
  if (($1 % 2 == 0)); then
    return 0
  else
    return 1
  fi
}

## Check if a number is odd
is_odd() {
  if is_even "$1"; then
    return 1
  else
    return 0
  fi
}

Ahora crea un script que use esta biblioteca:

touch use_library.sh

Agrega el siguiente contenido:

#!/bin/bash

## Source the math functions library
source math_functions.lib

## Display a header
echo "Math Functions Demo"
echo "------------------"

## Test the functions
echo "Addition: 5 + 3 = $(add 5 3)"
echo "Subtraction: 10 - 4 = $(subtract 10 4)"
echo "Multiplication: 6 * 7 = $(multiply 6 7)"

## Test division with error handling
div_result=$(divide 20 5)
if [ $? -eq 0 ]; then
  echo "Division: 20 / 5 = $div_result"
else
  echo "Division error: Cannot divide by zero"
fi

## Test division by zero
div_result=$(divide 20 0)
if [ $? -eq 0 ]; then
  echo "Division: 20 / 0 = $div_result"
else
  echo "Division error: Cannot divide by zero"
fi

echo "Power: 2 ^ 8 = $(power 2 8)"

## Test the even/odd functions
echo ""
echo "Number properties:"
for num in 1 2 3 4 5; do
  echo -n "Number $num is "

  if is_even $num; then
    echo "even"
  else
    echo "odd"
  fi
done

Guarda, hazlo ejecutable y ejecuta el script:

chmod +x use_library.sh
./use_library.sh

Deberías ver:

Math Functions Demo
------------------
Addition: 5 + 3 = 8
Subtraction: 10 - 4 = 6
Multiplication: 6 * 7 = 42
Division: 20 / 5 = 4.00
Division error: Cannot divide by zero
Power: 2 ^ 8 = 256

Number properties:
Number 1 is odd
Number 2 is even
Number 3 is odd
Number 4 is even
Number 5 is odd

Este enfoque de biblioteca demuestra cómo se pueden crear colecciones de funciones reutilizables que se pueden importar en múltiples scripts, promoviendo la reutilización de código y la mantenibilidad.

Resumen

En este tutorial, has aprendido los conceptos esenciales de los valores de retorno de las funciones en Bash. Comenzando con la creación básica de funciones y el manejo de argumentos, avanzaste hacia la comprensión de los códigos de retorno y cómo indican el éxito o el fracaso. Exploraste múltiples métodos para devolver datos reales desde las funciones, incluyendo el uso de echo, variables globales y delimitadores para múltiples valores.

A través de ejemplos prácticos, implementaste una utilidad de gestión de archivos que demostró una adecuada composición de funciones y manejo de errores. Finalmente, aprendiste las mejores prácticas para crear funciones robustas y reutilizables y cómo organizarlas en bibliotecas.

Las habilidades adquiridas en este tutorial proporcionan una base sólida para escribir scripts de Bash más sofisticados con un manejo adecuado de errores, modularidad y reutilización. Estas técnicas te permiten crear scripts de shell mantenibles para diversas tareas de automatización, mejorando tu productividad general como administrador de sistemas o desarrollador.