¡Hola! Bienvenido a la serie de tutoriales de secuencias de comandos de shell de HowToForge. Si desea leer las versiones anteriores del tutorial, no dude en hacer clic aquí para ver la parte 1, la parte 2, la parte 3 y la parte 4 del tutorial. En esta parte, aprenderá cómo estructurar eficientemente sus scripts mediante la creación de funciones. Al final de este tutorial, podrá saber cómo crear funciones en Linux Bash Shell, pasar parámetros a sus funciones y devolver algunos valores de una función a su código principal. ¡Empecemos!
Introducción
Una función, también conocida como subrutina en los 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 largo en pequeñas secciones que se pueden llamar cuando sea necesario. Cada función debe ser llamada por una rutina principal para ejecutarse, por lo tanto, está aislada con otras partes de su código y esto crea una forma fácil de probar el código. Además, las funciones se pueden llamar en cualquier momento y repetidamente, esto le permite reutilizar, optimizar y minimizar sus códigos. Como la mayoría de los lenguajes de programación, el shell bash también admite funciones.
Sintaxis general:
- Sintaxis 1:
función nombre_función
{
##### conjunto de comandos
} - Sintaxis 2:
nombre_función()
{
#### conjunto de comandos
}
Creando Funciones
El bash admite dos estructuras para funciones. Al usar la primera sintaxis, debe usar la función de palabra clave, seguida del nombre de su función y abrir y cerrar paréntesis y llaves para separar el contenido de sus funciones de su rutina principal. Esta sintaxis le resultará familiar si tiene experiencia en PHP porque las funciones en PHP se declaran de la misma manera. La otra sintaxis solo consiste en un nombre de función, paréntesis de apertura y cierre y llaves.
#!/bin/bash
mifunción(){
echo "¡Mi función funciona!"
}
mifunción
He usado la segunda sintaxis en nuestro ejemplo. Después de crear la función mifunción, se invocó llamando su nombre de función a nuestra rutina principal. La rutina principal estará en cualquier parte de nuestro script que no haya sido definida como parte de nuestra función.
Ahora reorganicemos nuestro código para probar si las funciones se pueden declarar en cualquier parte de nuestro script. Considere el siguiente código:
#!/bin/bash
echo "probando mi función"
mifunción
mifunción(){
echo "¡Mi función funciona!"
>/pre>
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 su rutina principal. El intérprete devolverá un error si ha declarado su función después de su rutina principal.Reestructuración de códigos usando funciones
Una de las mejores características de las funciones es poder reutilizar códigos. Cuando un procedimiento requiere la ejecución repetida de comandos, pero no se puede estructurar mediante declaraciones en bucle, entonces una función puede ser una solución.
Por ejemplo, considere el siguiente código:
#!/bin/bash
while(true)
do
clear
printf "Elija entre las siguientes operaciones:\n"
printf "[a ]adición\n[b]Resta\n[c]Multiplicación\n[d]División\n"
printf "#################### ###########\n"
lectura -p "Tu elección:" elección
case $elección en
[aA])
lectura -p "Ingrese el primer entero:" int1
read -p "Ingrese el segundo entero:" int2
res=$((int1+int2))
;;
[ bB])
read -p "Ingrese el primer entero:" int1
read -p "Ingrese el segundo entero:" int2
res=$((int1-int2))
;;
[cC])
read -p "Ingrese el primer entero:" int1
read -p "Ingrese el segundo entero:" int2
res=$(( int1*int2))
;;
[dD])
read -p "Ingrese el primer entero:" int1
read -p "Ingrese el segundo entero:" int2
res=$((int1/int2))
;;
*)
res=0
echo "¡Elección incorrecta!"
esac
echo "El resultado es:" $res
read -p "¿Desea continuar? [sí] o [n]o:" respuesta
si [ $respuesta =='n' ]
entonces
echo "Saliendo del script. ¡Que tengas un buen día!"
descanso
otros
continuar
fi
hecho
La secuencia de comandos funciona bien, sin embargo, tenga en cuenta que las líneas para aceptar entradas se realizan repetidamente en cada patrón en nuestra declaración de cambio.
#!/bin/bash
inputs(){
read -p "Ingrese el primer entero:" int1
read -p "Ingrese el segundo entero:" int2
}
exitPrompt(){
read -p "¿Desea continuar? [s]í o [n]o:" ans
if [ $ans =='n ' ]
entonces
echo "Saliendo del guión. ¡Que tengas un buen día!"
pausa
else
continuar
fi
}
while(true)
hacer
borrar
printf "Elija entre las siguientes operaciones:\n"
printf "[a]Adición\n[b] Resta\n[c]Multiplicación\n[d]División\n"
printf "########################## ####\n"
read -p "Tu elección:" elección
case $elección en
[aA])
entradas
res =$((int1+int2))
;;
[bB])
entradas
res=$((int1-int2))
;;
[cC])
entradas
res=$((int1*int2))
;;
[dD] )
entradas
res=$((int1/int2))
;;
*)
res=0
echo "¡Elección incorrecta!"
esac
echo "El resultado es:" $res
exitPrompt
hecho
Mejoramos nuestro código creando entradas de subsecciones y exitPrompt. Funciona exactamente igual con nuestro código anterior, sin embargo, nuestro código actual es más fácil de solucionar porque está estructurado correctamente.
Pasar parámetros en funciones
Como la mayoría de los lenguajes de programación, puede pasar parámetros y procesar esos datos en funciones en bash. El siguiente código muestra el procedimiento sobre cómo pasar valores en scripts de shell:
#!/bin/bash
mifunción(){
echo $1
echo $2
}
mifunción "Hola" "Mundo"
Observe que en nuestro ejemplo, agregamos 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 según la secuencia de paso de los parámetros, 1 como el nombre inicial hasta el orden de paso. Observe que la palabra "Hola" se almacena en la variable 1 y el valor "Mundo" se almacena en la variable 2.
Nota:El 1 y el 2 en nuestro ejemplo son variables locales y, por lo tanto, no son accesibles para otras partes del script además de la función donde se pasan los parámetros.
Por ejemplo,
#!/bin/bash
mifunción(){
echo $1
echo $2
}
mifunción "Hola" "Mundo"
eco $1
eco $2
El echo $1 y el echo $2 en las últimas dos líneas de nuestro script no se muestran ya que el intérprete no reconoce ambas variables porque ambas son locales para myfunction.
Valores devueltos de funciones
Además de crear funciones y pasarles parámetros, las funciones bash pueden pasar los valores de la variable local de una función a la rutina principal usando la palabra clave return. Los valores devueltos se almacenan en la variable predeterminada $? Por ejemplo, considere el siguiente código:
#!/bin/bash
add(){
sum=$(($1+$2))
return $sum
}
read -p "Ingrese un número entero:" int1
read -p "Ingrese un número entero:" int2
add $int1 $int2
echo "El resultado es:" $?
En el ejemplo, pasamos los parámetros int1 e int2 a la función de suma. A continuación, la función de suma lo 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. De forma predeterminada, 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. Echemos un vistazo en este ejemplo:
#!/bin/bash
add(){
sum=$(($1+$2))
dif=$(($1-$2))
return $sum
}
read -p "Ingrese un número entero:" int1
read -p "Ingrese un número entero:" int2
add $int1 $int2
echo "El resultado es:" $?
echo "El resultado es:" $?
Para resumirlo
Veamos otro ejemplo que usa funciones, le pasa parámetros y devuelve valor.
#!/bin/bash
####################
#Autor:HowtoForge #
### #################
borrar(){
borrar
}
bin( ){
bin1=$(echo "obase=2;$1"|bc)
echo $bin1
}
dec(){
dec1 =$(echo "ibase=2;$1"|bc)
return $dec1
}
########Principal####### ##
printf "Elija entre las siguientes operaciones:\n[1]Conversión de decimal a binario\n"
printf "[2]Conversión de binario a decimal\n"
read -p " Su elección:" op
case $op in
1)
read -p "Ingrese el número entero:" int
bin $int
;;
2)
read -p "Ingrese el número binario:" int
dec $int
echo "¿El equivalente decimal de $int es $?"
;;
*)
echo "¡Elección equivocada!"
esac
El ejemplo dado convierte una entrada dada a un valor binario o decimal usando el comando obase e ibase. La línea $(echo "obase=2;$1"|bc) convierte un valor decimal dado en un dígito binario y lo almacena en la variable bin1. A continuación mostramos el valor de $bin1 usando el comando echo.
Nota:es mejor usar echo directamente al convertir de decimal a binario porque cuando devuelves el comando para pasar un valor binario, bash convierte el valor binario a decimal antes de devolverlo.Además, hemos convertido el valor binario a decimal usando el comando $(echo "ibase=2;$1"|bc).
También debe recordar que el intérprete solo es capaz de aceptar dígitos binarios de 8 bits. Ingresará un dígito que exceda el límite de 8 bits, generará un desbordamiento y se descartará el bit más significativo del dígito.
El dígito binario de 10 bits 1000001010 devuelve 10 ya que, siguiendo la regla de los 8 bits, se omitirán los 2 bits restantes en el lado derecho (el bit más significativo), por lo que 1000001010 será igual a 00001010, que es igual a 10. Si desea una operación que acepte dígitos binarios que excedan los 8 bits, entonces debe crear el código manualmente.
Conclusión
Bash tiene funcionalidades 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, ha mejorado su conocimiento en secuencias de comandos de shell a través de funciones. Funciones en scripts de shell para proporcionar modularidad al usuario, lo que facilita la resolución de problemas de los scripts y permite la reutilización del código.
