D15

Las funciones en Shell son bloques de código en scripts de Shell compuestos por conjuntos de comandos y sentencias, que pueden ser llamados por otros scripts o por otras partes del mismo script. Esto permite modularizar el programa, es decir, dividir el código en bloques de tareas independientes, faciltiando la reutilización de estos bloques.

1. Definición de funciones

Sintaxis:

#Nombre de la función
[function] function_name() #La palabra function es opcional, si se usa, no son necesarias las ()
{
    #Cuerpo de la función, comandos a ejecutar
    commands...

    #Retorno de parámetros, la sentencia return es opcional,
    #si no se usa, el resultado de la última comando se toma como valor de retorno
    #si se usa return, se retorna el valor numérico n
    [ return [n]; ]
}    

#También se puede definir una función en una sola línea, separando los comandos con ;
function function_name { command1; command2; ... commandN; }
#o
function_name() { command1; command2; ... commandN; }

Se puede usar el comando interno unset con la opción -f para eliminar la definición de una función.

$ mi_funcion() { echo "Esta es la función a."; } #Definición

$ mi_funcion #Ejecución
Esta es la función a.

$ unset -f mi_funcion #Eliminación de la definición

$ mi_funcion #Intento fallido
-bash: mi_funcion: comando no encontrado

2. Parámetros, variables y valores de retorno de las funciones

3. Paso de parámetros a funciones

Las funciones de Shell tienen sus propios argumentos de línea de comandos, que se acceden mediante las variables especiales $1,$2...$n (parámetros posicionales).

Sintaxis de definición de función:

nombre_funcion(){
    arg1=$1
    arg2=$2
    comando_con_arg1
}

Sintaxis de llamada con parámetros:

nombre_funcion entrada1 entrada2

Donde:

nombre_funcion es el nombre de la función;

entrada1 es el parámetro 1, que se accede como $1 en la función;

entrada2 es el parámetro 2, que se accede como $2 en la función.

Ejemplo:

$ cat argumentos.sh 
#!/bin/bash
#20230525

recibir_parametros(){
        primer_parametro=$1

        echo "recibir_parametros(): \$0 es $0" #Muestra el parámetro 0, nombre del script
        echo "recibir_parametros(): \$1 es $1" #Muestra el primer parámetro de entrada
        echo "recibir_parametros(): \$primer_parametro es $primer_parametro" #Muestra el valor asignado a primer_parametro

        echo "recibir_parametros(): total args $#" #Muestra el número de parámetros
        echo "recibir_parametros(): todos los args(\$@) - \"$@\"" #Muestra todos los parámetros
        echo "recibir_parametros(): todos los args(\$*) - \"$*\"" #Muestra todos los parámetros
}

echo "###########Llamando a recibir_parametros por primera vez#############"
#Primera llamada a la función con un parámetro
recibir_parametros valor1

echo "###########Llamando a recibir_parametros por segunda vez#############"
#Segunda llamada a la función con tres parámetros
recibir_parametros valor1 valor2 valor3

#Ejecución
$ ./argumentos.sh 
###########Llamando a recibir_parametros por primera vez#############
recibir_parametros(): $0 es ./argumentos.sh
recibir_parametros(): $1 es valor1
recibir_parametros(): $primer_parametro es valor1
recibir_parametros(): total args 1
recibir_parametros(): todos los args($@) - "valor1"
recibir_parametros(): todos los args($*) - "valor1"
###########Llamando a recibir_parametros por segunda vez#############
recibir_parametros(): $0 es ./argumentos.sh
recibir_parametros(): $1 es valor1
recibir_parametros(): $primer_parametro es valor1
recibir_parametros(): total args 3
recibir_parametros(): todos los args($@) - "valor1 valor2 valor3"
recibir_parametros(): todos los args($*) - "valor1 valor2 valor3"

2. Variables locales

Por defecto, todas las variables en un script son globales. Modificar una variable dentro de una función cambiará su valor en todo el script, lo que puede causar problemas.

Se puede usar el comando local para crear una variable local.

Sintaxis:

local var=valor
local nombre_var<br></br><br></br>nombre_funcion(){<br></br>　　local var=$1<br></br>　　comando_con_var<br></br>}<br></br>

Nota:

El comando local solo se puede usar dentro de funciones;

El comando local limita el alcance de la variable al interior de la función.

Ejemplo$ cat variables_locales.sh

#!/bin/bash
#20230525

variable_global="global_normal" #Variable externa a
funcion_local() { local variable=$1; echo "variable local es: $variable."; } #variable en funcion_local definida como local
echo "variable antes de llamar a funcion_local: $variable_global"

funcion_local valor_local #llamada a funcion_local, establece el valor de la variable local
echo "variable después de llamar a funcion_local: $variable_global"

variable_b="global_b" #Variable externa b
funcion_global() { variable_b=$1; echo "variable b es $variable_b."; } #variable en funcion_global es normal
echo "variable b antes de llamar a funcion_global: $variable_b"<br></br><br></br>funcion_global valor_global #llamada a funcion_global, establece el valor de variable_b
echo "variable b después de llamar a funcion_global: $variable_b" 

#Ejecución
$ ./variables_locales.sh 
variable antes de llamar a funcion_local: global_normal
variable local es: valor_local. #la variable local en funcion_local toma el valor de la llamada
variable después de llamar a funcion_local: global_normal #el valor de la variable externa no se modificó
variable b antes de llamar a funcion_global: global_b
variable b es valor_global.
variable b después de llamar a funcion_global: valor_global #el valor de la variable externa b se modificó

3. Comando return

Ejemplo:

$ cat retorno.sh
#!/bin/bash
#20230525

verificar_proceso()
{
        local i

        for i in $*
        do
                [ -d "/proc/$i" ] && return 0 #si el directorio del proceso existe, retorna 0
        done

        return 1 #en caso contrario, retorna 1
}

echo "#########verificar_proceso de proceso existente############"
verificar_proceso 24249 #proceso existente, retorna 0
echo $?

echo "#########verificar_proceso de proceso inexistente############"
verificar_proceso 4444 #inexistente, retorna 1
echo $?

#Ejecución
$ ./retorno.sh 
#########verificar_proceso de proceso existente############
0
#########verificar_proceso de proceso inexistente############
1

4. Prueba de valores de retorno de funciones

Se usa $? para obtener el estado de salida del último comando ejecutado en primer plano.

echo "#########verificar_proceso de varios procesos########"
verificar_proceso $pid1 $pid2 $pid3

if [ $? = 0 ] #evaluar el resultado
then
        echo "Al menos uno está en ejecución!"
else
        echo "Ninguno está en ejecución!"
fi

Fin de esta sección