ShellScript

Un shell script es un archivo de texto que contiene una serie de comandos que se ejecutan secuencialmente en un intérprete de comandos (o shell) en sistemas operativos como Linux o Unix. Estos scripts se utilizan para automatizar tareas repetitivas, configurar sistemas o realizar operaciones complejas de manera eficiente.

Componentes principales de un shell script

1. Intérprete de comandos (Shell):

   • Los shell scripts se ejecutan en un intérprete como Bash, Zsh, Ksh, entre otros.
   • El shell más común es Bash (Bourne Again Shell).

2. Extensión:

   • Generalmente tienen la extensión .sh para identificarlos, aunque no es obligatoria.

3. Encabezado Shebang (#!):

   • El primer par de caracteres de un script, #!, seguido de la ruta al intérprete, especifica qué shell debe ejecutar el script.
   • Ejemplo:

     #!/bin/bash
     

4. Comandos:

   • Contienen comandos del sistema, variables, bucles, condicionales y funciones.

Usos comunes de los shell scripts

1. Automatización de tareas:

   • Realizar copias de seguridad.
   • Actualizar paquetes.

2. Mantenimiento de sistemas:

   • Configuración de servidores.
   • Limpieza de archivos temporales.

3. Procesamiento de archivos y datos:

   • Manipular archivos de texto.
   • Analizar registros o logs.

4. Interacción con bases de datos:

   • Consultar y actualizar bases de datos con herramientas como mysql o psql.

Ventajas

• Fácil de escribir y ejecutar.
• Disponible en cualquier sistema Linux o Unix.
• Permite combinar comandos del sistema en un solo archivo.

Desventajas

• Menor rendimiento comparado con lenguajes compilados.
• Difícil de depurar en scripts complejos.
• Dependencia del shell (puede no ser portable entre sistemas).

Shell Script vs Bash Script: ¿Cuál es la diferencia?

Aunque muchas personas usan los términos shell script y bash script de manera intercambiable, tienen diferencias clave que vale la pena entender, especialmente si estás aprendiendo sobre scripting en sistemas Linux o Unix.

1. Shell Script: El concepto general

Un shell script es un archivo de texto que contiene una serie de comandos que se ejecutan en un intérprete de comandos. El “shell” se refiere al programa que interpreta los comandos. Hay varios tipos de shells, y los scripts escritos para ellos se llaman shell scripts.

Tipos de shells comunes:

1. Bash (Bourne Again Shell): El más popular en sistemas Linux.
2. Zsh (Z Shell): Más moderno y personalizable.
3. Ksh (Korn Shell): Común en sistemas Unix.
4. Sh (Bourne Shell): Shell básico y estándar en Unix.
5. Tcsh: Una versión mejorada del C Shell.

Cuando decimos “shell script”, nos referimos a cualquier script que pueda ejecutarse en un shell, sin importar cuál sea.

2. Bash Script: Un tipo específico de shell script

Un bash script es un tipo de shell script que está escrito específicamente para el shell Bash (Bourne Again Shell). Bash es el intérprete de comandos más común en sistemas Linux y es una mejora del shell original Bourne (sh).

Características de Bash:

• Compatible con scripts de sh.
• Añade funcionalidades avanzadas como:
  • Expansión de corchetes ({}).
  • Manejo mejorado de arrays.
  • Control de trabajos (jobs, fg, bg).
  • Funciones específicas (declare, [[ ]] para comparaciones avanzadas).

Un script que comienza con la línea #!/bin/bash está diseñado específicamente para ejecutarse en Bash.

Diferencias clave entre Shell Script y Bash Script

3. Ejemplos de Shell Script vs Bash Script

Shell Script genérico (compatible con múltiples shells):

#!/bin/sh

echo "Este es un shell script genérico."
echo "Funciona en cualquier shell compatible con POSIX."

Bash Script (aprovecha características avanzadas de Bash):

#!/bin/bash

echo "Este es un bash script."
# Uso de arrays (disponibles en Bash, pero no en todos los shells)
nombres=("Ana" "Juan" "Luis")
for nombre in "${nombres[@]}"; do
    echo "Hola, $nombre"
done

4. Cuándo usar cada uno

• Shell Script:

  • Cuando necesitas portabilidad entre diferentes sistemas Unix/Linux.
  • Ideal para scripts simples compatibles con múltiples shells.

• Bash Script:

  • Cuando puedes garantizar que Bash está disponible (Linux moderno).
  • Si necesitas funcionalidades avanzadas específicas de Bash.
  • Cuando trabajas en entornos Linux que usan Bash por defecto.

5. Resumen

Conclusión

Un bash script siempre es un shell script, pero no todos los shell scripts son bash scripts. La elección entre uno y otro depende de tus necesidades: si buscas portabilidad, opta por un shell script genérico. Si trabajas en entornos controlados donde Bash está garantizado, aprovecha las funcionalidades avanzadas de un bash script.

Shebang y comentarios

Shebang y Comentarios en Shell Scripting

1. ¿Qué es el Shebang?

El shebang es una secuencia de caracteres que se coloca en la primera línea de un script para indicar qué intérprete (o shell) debe ejecutar el script. Un shebang comienza con #! seguido de la ruta al intérprete.

Sintaxis del Shebang

#!/ruta/al/interprete

Ejemplo común

En la mayoría de los bash scripts, el shebang apunta al intérprete bash:

#!/bin/bash

Esto indica que el script debe ejecutarse usando el shell Bash (Bourne Again Shell), que es el más común en sistemas Linux.

¿Por qué es importante el Shebang?

• Especifica el intérprete: Permite que el sistema sepa qué intérprete utilizar, incluso si ejecutas el script directamente, sin llamar al intérprete explícitamente.
• Portabilidad: Ayuda a que el script funcione correctamente en diferentes sistemas, siempre que el intérprete especificado esté disponible en la misma ruta.

Ejemplos de Shebang con diferentes intérpretes

• Bash:

  #!/bin/bash
  

• Python:

  #!/usr/bin/python3
  

• Perl:

  #!/usr/bin/perl
  

• Sh (shell genérico):

  #!/bin/sh
  

Ejemplo de uso en un script

#!/bin/bash
echo "Este es un script en Bash"

Si guardas este script y le das permisos de ejecución, puedes ejecutarlo directamente desde la línea de comandos:

./mi_script.sh

2. Comentarios en Shell Scripting

Los comentarios son líneas o partes de código que el intérprete ignora al ejecutar el script. Se utilizan para agregar notas y explicaciones que ayudan a comprender el propósito o funcionamiento de ciertas partes del script.

En shell scripting, los comentarios comienzan con el carácter #. Todo lo que sigue a # en esa línea se considera un comentario.

Por qué usar comentarios

• Documentación: Explican lo que hace cada parte del script, facilitando su comprensión.
• Mantenimiento: Ayudan a otros (o a ti mismo en el futuro) a modificar el script sin cometer errores.
• Depuración: Permiten desactivar temporalmente partes del código para probar otras secciones.

Ejemplos de Comentarios en Shell Scripting

1. Comentario en una línea

   # Este es un comentario en una sola línea
   echo "Hola, mundo!"
   

2. Comentario al final de una línea de código

   echo "Hola, mundo!"  # Este comentario explica el comando
   

3. Bloque de comentarios (multi-línea)

   Aunque Bash no tiene un bloque de comentarios específico, puedes crear comentarios en varias líneas utilizando # en cada línea:

   # Este es un bloque de comentarios
   # donde explicamos el siguiente
   # conjunto de comandos
   

4. Desactivar líneas de código

   Puedes comentar temporalmente líneas de código para evitar que se ejecuten:

   # echo "Esta línea está desactivada temporalmente"
   echo "Esta línea sí se ejecutará"
   

Ejemplo Completo: Uso de Shebang y Comentarios

Aquí tienes un ejemplo de un script que usa shebang y varios comentarios para explicar lo que hace cada parte:

#!/bin/bash
# Este script saluda al usuario y muestra la fecha

# Imprimir un saludo
echo "Hola, $USER!"  # Muestra el nombre del usuario actual

# Mostrar la fecha actual
echo "La fecha y hora actual es:"
date  # Comando para mostrar la fecha y hora

Este script hace lo siguiente:

1. El shebang #!/bin/bash indica que el script se ejecutará en Bash.
2. Los comentarios explican cada paso, haciendo que el script sea fácil de entender.

Consejos para el uso de Shebang y Comentarios

1. Usa el shebang solo en la primera línea del script.
2. Agrega comentarios donde sea necesario, especialmente en partes del código que pueden no ser obvias.
3. Sé claro y breve en los comentarios; no describas lo obvio, pero explica cualquier operación compleja o importante.
4. Usa comentarios para depuración: Comentar partes de código temporalmente puede ayudarte a encontrar y corregir errores.

Resumen

• Shebang (#!): Especifica el intérprete de comandos que ejecutará el script, normalmente en la primera línea.
• Comentarios (#): Agregan notas explicativas al código y ayudan a que el script sea comprensible y fácil de mantener.

Estos dos elementos son esenciales en cualquier shell script bien estructurado, ya que hacen que el código sea más claro, organizado y fácil de ejecutar en el entorno correcto.

Ejemplo

!#/bin/bash

echo "hola mundo"

Tenemos que darle permisos con chmod +x ./hola_mundo.sh y luego ejecutarlo con su ruta relativa ./

./hola_mundo

Veremos el resultado en la shell

Variables

Las variables son uno de los conceptos fundamentales en los scripts de shell (como los escritos para sh o bash). Aquí tienes todo lo que necesitas saber sobre las variables en shell scripting:

1. Definición y Declaración

En un script de shell, las variables se crean simplemente asignando un valor:

variable="valor"

Características:

• No se utiliza un tipo explícito (todas las variables son cadenas de texto por defecto).
• No debe haber espacios alrededor del signo igual =:

  variable = "valor"  # Error
  variable="valor"    # Correcto
  

Acceso a una Variable

Para usar una variable, se antepone el símbolo $:

echo $variable

O, si está dentro de una cadena de texto compleja, se usa con llaves {} para evitar ambigüedades:

echo "El valor es ${variable}"

2. Tipos de Variables

a) Locales

• Definidas en el script actual y no afectan el entorno fuera de él.
• Ejemplo:

  local_var="hola"
  echo $local_var
  

b) De Entorno

• Variables globales disponibles para el shell y los procesos hijo.
• Se exportan usando el comando export:

  export global_var="mundo"
  echo $global_var
  

c) Posicionales

• Representan argumentos pasados al script o función.
• Ejemplo:

  ./mi_script.sh arg1 arg2
  

  Acceso:
  • $0: Nombre del script.
  • $1, $2, …, $N: Argumentos posicionales.
  • $#: Número total de argumentos.
  • $@: Todos los argumentos como una lista.
  • $*: Todos los argumentos como una cadena.

d) Variables Especiales

• $?: Código de salida del último comando.
• $$: ID del proceso actual.
• $!: ID del último proceso en segundo plano.
• $-: Opciones de shell activas.
• $_: Último argumento del último comando ejecutado.

3. Asignación de Valores

a) Asignación Directa

variable="valor"

b) Lectura de Entrada

Usa el comando read para asignar valores desde la entrada estándar:

read variable
echo "Ingresaste: $variable"

c) Evaluación de Comandos

Puedes asignar el resultado de un comando:

fecha=$(date)
echo "La fecha es $fecha"

4. Ámbito de Variables

a) Variables Locales

• Definidas dentro de funciones o scripts y no están disponibles fuera de ellos.
• Usa local para restringir el ámbito en funciones:

  mi_funcion() {
    local var="local"
    echo $var
  }
  

b) Variables Globales

• Disponibles en todo el entorno del script.
• Sin local, todas las variables son globales en el contexto del script.

5. Sustitución de Variables

a) Valores por Defecto

Útil para dar valores predeterminados:

echo ${variable:-"valor_por_defecto"}

• Si variable está vacía o no está definida, se usa "valor_por_defecto".

b) Sustitución Obligatoria

Genera un error si la variable no está definida:

echo ${variable:?"La variable no está definida"}

c) Sustitución de Subcadenas

Extraer partes de una cadena:

variable="hola mundo"
echo ${variable:0:4}  # "hola"

d) Sustitución de Patrones

Eliminar parte de una cadena:

variable="archivo.txt"
echo ${variable%.txt}  # "archivo" (elimina la extensión)

6. Buenas Prácticas

a) Comillas

Usa comillas para evitar problemas con espacios o caracteres especiales:

variable="Hola Mundo"
echo "$variable"

b) Evitar Confusión con Comandos

Evita sobrescribir variables con nombres de comandos (ls, date, etc.).

c) Debugging

Activa el modo de depuración para rastrear errores:

set -x  # Inicia modo de depuración
set +x  # Detiene modo de depuración

7. Ejemplo Completo

#!/bin/bash

# Variables globales
nombre="Juan"
export saludo="Hola"

# Función con variables locales
mi_funcion() {
  local local_var="Variable Local"
  echo "Dentro de la función: $local_var"
}

# Asignación de comando
fecha=$(date)

# Uso de variables especiales
echo "El script se llama: $0"
echo "Número de argumentos: $#"
echo "Primer argumento: $1"

# Uso de sustitución de variables
echo "Saludo: ${saludo:-"Hola por defecto"}"
echo "Fecha: $fecha"

# Llamar función
mi_funcion

¡Claro! Aquí tienes un formato explicativo para incluir en tu blog:

Cómo Renombrar Archivos Usando Variables en un Script de Shell

Cuando trabajamos con scripts de shell, a menudo necesitamos realizar operaciones dinámicas, como renombrar archivos, dependiendo de valores almacenados en variables. En este artículo, exploraremos cómo hacerlo de forma sencilla y eficiente con un ejemplo práctico.

El Código

Este es el fragmento de código que vamos a analizar:

nombre_fichero="mifichero.txt"
mv "$nombre_fichero" "${nombre_fichero}.new"

Este pequeño script usa una variable para almacenar el nombre de un archivo y luego lo renombra añadiendo una extensión adicional .new. ¡Vamos a desglosarlo!

Desglose del Código

1. Definición de una Variable

nombre_fichero="mifichero.txt"

• Creamos una variable llamada nombre_fichero y le asignamos el valor "mifichero.txt".
• En un script de shell, las variables se definen sin usar tipos de datos (todo se trata como texto por defecto).
• Ahora, esta variable contiene el nombre del archivo que vamos a manipular.

2. Uso del Comando mv

mv "$nombre_fichero" "${nombre_fichero}.new"

Aquí utilizamos el comando mv para renombrar el archivo. Veamos qué hace cada parte:

• mv:

  • Es el comando de shell para mover o renombrar archivos y directorios.

• "$nombre_fichero":

  • Se refiere al valor almacenado en la variable nombre_fichero, que es "mifichero.txt".
  • Las comillas dobles aseguran que, si el nombre del archivo tiene espacios u otros caracteres especiales, no cause problemas.

• "${nombre_fichero}.new":

  • Construye un nuevo nombre para el archivo concatenando el valor de la variable con la extensión .new.
  • Por ejemplo, si nombre_fichero es "mifichero.txt", este fragmento se convierte en "mifichero.txt.new".

Qué Hace el Script

1. Busca un archivo con el nombre almacenado en nombre_fichero (en este caso, mifichero.txt).
2. Lo renombra añadiendo .new al final del nombre original, resultando en mifichero.txt.new.

Ejemplo Práctico

Imaginemos que tenemos un archivo llamado mifichero.txt en el directorio actual:

Antes de ejecutar el script:

ls
# Salida:
# mifichero.txt

Ejecutamos el script:

nombre_fichero="mifichero.txt"
mv "$nombre_fichero" "${nombre_fichero}.new"

Después de ejecutarlo, el archivo será renombrado:

ls
# Salida:
# mifichero.txt.new

¿Por Qué Usar Variables Aquí?

Usar variables en lugar de escribir los nombres de archivo directamente en los comandos tiene varias ventajas:

1. Flexibilidad:

   • Si necesitas cambiar el nombre del archivo, solo debes modificar el valor de la variable, sin alterar el resto del script.

2. Reutilización:

   • Puedes usar la misma variable en diferentes partes del script.

3. Claridad:

   • Las variables hacen que el código sea más fácil de leer y mantener.

Errores Comunes y Cómo Evitarlos

1. El archivo no existe:

   • Si el archivo especificado en nombre_fichero no está en el directorio actual, obtendrás un error como:

     mv: cannot stat 'mifichero.txt': No such file or directory
     

     Solución: Asegúrate de que el archivo existe antes de ejecutar el script.

2. Espacios en el nombre del archivo:

   • Si el nombre del archivo tiene espacios (por ejemplo, mi fichero.txt), es esencial usar comillas dobles:

     mv "$nombre_fichero" "${nombre_fichero}.new"
     

     Esto evitará que el shell interprete los espacios como separadores de argumentos.

Conclusión

El uso de variables en scripts de shell no solo simplifica la manipulación de archivos, sino que también mejora la claridad y flexibilidad del código. Este ejemplo de renombrar un archivo es una técnica básica pero poderosa que puedes adaptar fácilmente a tareas más complejas.

Si te gustó esta explicación o tienes preguntas, ¡déjame tus comentarios y seguimos aprendiendo juntos!

Constantes

En shell scripting, constantes como concepto formal no existen, ya que todas las variables son modificables por naturaleza. Sin embargo, se pueden implementar constantes de manera efectiva siguiendo algunas prácticas comunes. Aquí tienes todo lo que necesitas saber:

¿Qué son las constantes?

Una constante es un valor que se define una vez y no debe cambiar durante la ejecución del script. Aunque el shell no tiene un mecanismo específico para declarar constantes, hay formas de simularlas.

Cómo Implementar Constantes en Shell Scripting

1. Usar Variables de Solo Lectura

El comando readonly marca una variable como no modificable después de su asignación inicial. Esto simula el comportamiento de una constante.

readonly NOMBRE_CONSTANTE="valor"

• Si intentas modificar la variable después de marcarla como readonly, el shell generará un error:

  NOMBRE_CONSTANTE="nuevo_valor"
  # Error: bash: NOMBRE_CONSTANTE: readonly variable
  

Ejemplo:

readonly PI=3.14159
echo "El valor de PI es $PI"

# Intento de cambio
PI=3.14
# Salida: bash: PI: readonly variable

2. Definir Variables con declare -r

El comando declare permite marcar una variable como de solo lectura usando el flag -r.

declare -r NOMBRE_CONSTANTE="valor"

Esto es equivalente a readonly y produce el mismo efecto.

Ejemplo:

declare -r USUARIO="admin"
echo "Usuario: $USUARIO"

# Intento de cambio
USUARIO="guest"
# Salida: bash: USUARIO: readonly variable

3. Usar Convenciones de Nombres

Aunque no es obligatorio, es buena práctica usar nombres en mayúsculas para indicar que una variable es una constante. Esto mejora la legibilidad del script.

Ejemplo:

readonly MAX_INTENTOS=5
readonly TIEMPO_ESPERA=10

4. Usar Scripts de Solo Lectura

Para evitar cambios accidentales en las constantes, puedes definirlas en un script separado y asegurarte de que este archivo sea de solo lectura (chmod 444).

Ejemplo:

Archivo constantes.sh:

readonly API_KEY="12345"
readonly BASE_URL="https://api.ejemplo.com"

Usar las constantes en otro script:

source constantes.sh
echo "API Key: $API_KEY"

Errores Comunes con Constantes

1. Intentar Redefinir Constantes

Una vez que una constante está marcada como readonly, no puede ser redefinida. Esto genera errores en tiempo de ejecución:

readonly MI_CONSTANTE="valor"
MI_CONSTANTE="nuevo_valor"
# Salida: bash: MI_CONSTANTE: readonly variable

2. No Usar Comillas

Si una constante contiene espacios o caracteres especiales, omitir las comillas puede causar problemas:

readonly MENSAJE="Hola Mundo"
echo $MENSAJE
# Correcto: "Hola Mundo"

readonly MENSAJE=Hola Mundo
# Error: El shell interpreta "Hola" y "Mundo" como argumentos separados.

Ejemplo Completo

Aquí tienes un ejemplo práctico que combina el uso de constantes con un script funcional:

#!/bin/bash

# Declaración de constantes
readonly PI=3.14159
readonly MAX_INTENTOS=3
readonly MENSAJE_BIENVENIDA="¡Bienvenido al sistema!"

# Uso de constantes
echo $MENSAJE_BIENVENIDA
echo "El valor de PI es $PI"
echo "Número máximo de intentos: $MAX_INTENTOS"

# Intento de cambio (provoca un error)
MAX_INTENTOS=5

Al ejecutar este script, obtendrás un error si intentas modificar MAX_INTENTOS.

Conclusión

Aunque los scripts de shell no soportan directamente constantes como en otros lenguajes de programación, puedes simularlas fácilmente usando readonly, declare -r y convenciones de nombres. Estas prácticas te ayudarán a escribir scripts más robustos y fáciles de mantener.

Here Documents en Shell Scripting

Un Here Document (documento aquí) es una técnica en shell scripting que permite enviar bloques de texto al estándar de entrada de un comando o programa. Se usa para alimentar comandos o configuraciones complejas directamente a otro programa sin necesidad de archivos intermedios.

Diferencias entre echo y <<EOF

Ejemplo Comparativo

Con echo:

echo "open ftp.example.com
user username password
put file.txt
bye" | ftp -n

Con <<EOF:

ftp -n <<EOF
open ftp.example.com
user username password
put file.txt
bye
EOF

En este caso, <<EOF es más claro y fácil de mantener, especialmente para configuraciones más largas.

Ventajas de <<EOF

1. Legibilidad: Permite escribir múltiples líneas directamente en el script, sin necesidad de combinar múltiples comandos echo.
2. Facilidad para configuraciones complejas: Perfecto para alimentar scripts completos o configuraciones a comandos como ftp, ssh, etc.
3. Flexibilidad: Admite la expansión de variables y el uso de comandos dentro del bloque.

Ejemplo: Uso con FTP (ftp -n)

Un script completo que utiliza ftp -n con <<EOF:

#!/bin/bash

# Variables
FTP_HOST="ftp.example.com"
FTP_USER="username"
FTP_PASS="password"
LOCAL_FILE="archivo_local.txt"
REMOTE_FILE="archivo_remoto.txt"

# Script FTP con Here Document
ftp -n <<EOF
open $FTP_HOST
user $FTP_USER $FTP_PASS
put $LOCAL_FILE $REMOTE_FILE
bye
EOF

Explicación del Script

1. ftp -n:
   • Ejecuta FTP sin usar un archivo de configuración interactivo.
2. <<EOF:
   • Envía las líneas dentro del bloque como entrada estándar al comando ftp.
3. Variables:
   • $FTP_HOST, $FTP_USER, etc., son expandidas dentro del bloque, permitiendo configuraciones dinámicas.
4. Comandos de FTP:
   • open: Conecta al servidor FTP.
   • user: Inicia sesión con el usuario y contraseña.
   • put: Sube un archivo local (archivo_local.txt) al servidor remoto con el nombre archivo_remoto.txt.
   • bye: Finaliza la sesión.

Ejecutar un Script Después de FTP con el Estándar de Entrada

Puedes usar el estándar de entrada (stdin) para ejecutar comandos o scripts automáticamente después de una sesión de FTP.

Ejemplo

Un script que sube un archivo vía FTP y luego ejecuta comandos adicionales:

#!/bin/bash

# FTP Script con entrada estándar
ftp -n <<EOF | bash
open ftp.example.com
user username password
put archivo_local.txt archivo_remoto.txt
bye
EOF

# Comandos adicionales
echo "Archivo subido correctamente. Ejecutando el siguiente paso..."
ls -l archivo_local.txt

Explicación

1. ftp -n <<EOF | bash:
   • La salida de ftp se canaliza (|) como entrada para el shell (bash), permitiendo ejecutar comandos posteriores.
2. Comandos adicionales:
   • Se ejecutan una vez que el bloque FTP ha finalizado.

Conclusión

• <<EOF es ideal para trabajar con configuraciones complejas y bloques de comandos legibles.
• Puedes usarlo para enviar scripts a ftp, ssh, y otros programas que acepten entrada estándar.
• Conecta ftp -n al estándar de entrada para ejecutar acciones adicionales tras una transferencia.

Funciones

¡Por supuesto! Aquí tienes un artículo explicativo sobre funciones en shell scripting que puedes usar para tu blog:

Guía Completa: Cómo Usar Funciones en Shell Scripting

Las funciones son bloques de código reutilizables que permiten estructurar mejor los scripts de shell, reducir la duplicación y mejorar la legibilidad. Si alguna vez has creado un script extenso y repetitivo, las funciones son la solución ideal.

En esta guía, aprenderás todo lo necesario para trabajar con funciones en shell scripting.

¿Qué es una Función en Shell Script?

Una función es un bloque de código que realiza una tarea específica. Puede ser llamada varias veces en un script, ahorrando esfuerzo y reduciendo errores.

Sintaxis Básica

nombre_funcion() {
    # Bloque de código
}

O bien, una variante menos común:

function nombre_funcion {
    # Bloque de código
}

Ambas formas son equivalentes.

Cómo Definir y Usar una Función

1. Definición de la Función

mi_funcion() {
    echo "Hola, esta es mi primera función."
}

2. Llamada a la Función

mi_funcion

Cuando el script llega a la llamada de la función, ejecuta el bloque de código definido.

Ejemplo Básico

Un ejemplo simple para imprimir un mensaje:

#!/bin/bash

saludar() {
    echo "¡Hola desde la función saludar!"
}

# Llamar a la función
saludar

Salida:

¡Hola desde la función saludar!

Uso de Parámetros en Funciones

Puedes pasar argumentos a las funciones de la misma manera que lo haces con scripts. Los parámetros se acceden usando $1, $2, …, $N.

Ejemplo: Función con Parámetros

#!/bin/bash

sumar() {
    resultado=$(( $1 + $2 ))
    echo "La suma de $1 y $2 es $resultado"
}

# Llamar a la función con argumentos
sumar 5 7

Salida:

La suma de 5 y 7 es 12

Uso de return en Funciones

Las funciones pueden devolver un valor numérico usando return, que se utiliza para representar un código de estado (exit code).

Ejemplo: Usar return

#!/bin/bash

verificar_par() {
    if (( $1 % 2 == 0 )); then
        return 0  # Es par
    else
        return 1  # No es par
    fi
}

# Llamar a la función
verificar_par 4
if [[ $? -eq 0 ]]; then
    echo "El número es par"
else
    echo "El número no es par"
fi

Salida:

El número es par

Nota: return solo admite valores numéricos entre 0 y 255. Para devolver valores complejos, usa echo (ver siguiente sección).

Devolver Valores con echo

Para devolver cadenas o valores complejos, usa echo y captura el resultado con sustitución de comandos ($(...)).

Ejemplo: Devolver Valores

#!/bin/bash

obtener_fecha() {
    echo $(date +"%Y-%m-%d")
}

# Llamar a la función y capturar el valor devuelto
fecha=$(obtener_fecha)
echo "La fecha de hoy es: $fecha"

Salida:

La fecha de hoy es: 2024-11-16

Alcance de Variables en Funciones

1. Variables Globales

Por defecto, las variables declaradas en una función son accesibles desde cualquier parte del script.

#!/bin/bash

global="Soy una variable global"

mi_funcion() {
    echo "Dentro de la función: $global"
}

mi_funcion
echo "Fuera de la función: $global"

2. Variables Locales

Para restringir el alcance de una variable a una función, usa local.

#!/bin/bash

mi_funcion() {
    local local_var="Soy local"
    echo $local_var
}

mi_funcion
echo $local_var  # No está disponible fuera de la función

Salida:

Soy local
bash: local_var: unbound variable

Buenas Prácticas

1. Nombres Descriptivos:

   • Usa nombres claros que indiquen lo que hace la función.

   descargar_archivos() { ... }
   

2. Modularidad:

   • Divide scripts grandes en funciones más pequeñas y manejables.

3. Uso de Variables Locales:

   • Evita conflictos de nombres usando local en variables dentro de funciones.

4. Comentarios:

   • Documenta el propósito de cada función.

Ejemplo Completo

Un script que utiliza funciones para saludar al usuario, sumar números y mostrar la fecha actual.

#!/bin/bash

# Función para saludar
saludar() {
    echo "Hola, $1. Bienvenido al sistema."
}

# Función para sumar dos números
sumar() {
    resultado=$(( $1 + $2 ))
    echo "La suma de $1 y $2 es $resultado"
}

# Función para mostrar la fecha actual
mostrar_fecha() {
    echo "La fecha de hoy es: $(date +"%Y-%m-%d")"
}

# Llamar a las funciones
saludar "Juan"
sumar 10 20
mostrar_fecha

Salida:

Hola, Juan. Bienvenido al sistema.
La suma de 10 y 20 es 30
La fecha de hoy es: 2024-11-16

Conclusión

Las funciones son una herramienta esencial para escribir scripts de shell más claros, organizados y reutilizables. Ya sea para realizar cálculos, procesar datos o automatizar tareas, las funciones hacen que tu código sea más modular y fácil de mantener.

Ejemplo con todo lo aprendido en este post :

#!/bin/bash
     
    # Este programa parse los resultados de nmap y construye un documento html
     
    TITULO="Resultados nmap"
    FECHA_ACTUAL="$(date)"
    TIMESTAMP="Informe generado el $FECHA_ACTUAL por el usuario $USERNAME"
     
    nmap_exec () {
        echo "[INFO] Ejecutando nmap en la red $1, por favor espere unos segundos..."
        sudo nmap -sV $1 > $2
        echo "[OK] Fichero $2 generado correctamente"
        return 0
    }
     
    generar_html () {
    cat <<EOF
    <html>
        <head>
            <title>$TITULO</title>
       </head>
      <body>
        <h1>$TITULO</h1>
        <p1>$TIMESTAMP</p1>
      </body>
    </html>
     
    EOF
    }
     
    #Generamos el reporte raw con nmap
    nmap_exec "192.168.239.0/24" "salida_nmap.raw"
     
    # Generamos el reporte con los resultados de nmap en HTML
    echo "[INFO] Generando reporte html..."
    generar_html > resultados_nmap.html
    echo "[OK] Reporte resultados_nmap.html generado correctamente"