Valor de retorno en una función Bash

Estoy trabajando con un script bash y quiero ejecutar una función para imprimir un valor de retorno:

function fun1(){
  return 34
}
function fun2(){
  local res=$(fun1)
  echo $res
}

Cuando ejecuto fun2, no imprime "34". ¿Por qué es este el caso?

Aunque bash tiene una returndeclaración, lo único que puede especificar con ella es el exitestado propio de la función (un valor entre 0y 255, 0 significa "éxito"). Entonces returnno es lo que quieres.

Es posible que desee convertir su returndeclaración en una echodeclaración, de esa manera la salida de su función podría capturarse usando $()llaves, que parece ser exactamente lo que desea.

Aquí hay un ejemplo:

function fun1(){
  echo 34
}

function fun2(){
  local res=$(fun1)
  echo $res
}

Otra forma de obtener el valor de retorno (si solo desea devolver un entero 0-255) es $?.

function fun1(){
  return 34
}

function fun2(){
  fun1
  local res=$?
  echo $res
}

Además, tenga en cuenta que puede usar el valor de retorno para usar la lógica booleana, fun1 || fun2ya que solo se ejecutará fun2si fun1devuelve un 0valor. El valor de retorno predeterminado es el valor de salida de la última instrucción ejecutada dentro de la función.

$(...)captura el texto enviado a stdout por el comando que contiene. returnno sale a stdout. $?contiene el código de resultado del último comando.

fun1 (){
  return 34
}

fun2 (){
  fun1
  local res=$?
  echo $res
}

Las funciones en Bash no son funciones como en otro idioma; en realidad son comandos. Por lo tanto, las funciones se usan como si fueran binarios o scripts extraídos de su ruta. Desde la perspectiva de la lógica de su programa, realmente no debería haber diferencia.

Los comandos de Shell están conectados por canalizaciones (también conocidos como flujos) y no por tipos de datos fundamentales o definidos por el usuario, como en los lenguajes de programación "reales". No existe un valor de retorno para un comando, tal vez principalmente porque no hay una forma real de declararlo. Podría ocurrir en la página de manual o en la --helpsalida del comando, pero ambos son legibles por humanos y, por lo tanto, están escritos al viento.

Cuando un comando quiere obtener una entrada, la lee de su flujo de entrada o de la lista de argumentos. En ambos casos, las cadenas de texto deben analizarse.

Cuando un comando quiere devolver algo, debe echohacerlo en su flujo de salida. Otra forma practicada a menudo es almacenar el valor de retorno en variables dedicadas y globales. Escribir en la secuencia de salida es más claro y más flexible, porque también puede tomar datos binarios. Por ejemplo, puede devolver un BLOB fácilmente:

encrypt() {
    gpg -c -o- $1 # encrypt data in filename to stdout (asks for a passphrase)
}

encrypt public.dat > private.dat # write function result to file

Como otros han escrito en este hilo, la persona que llama también puede usar la sustitución de comandos $()para capturar la salida.

Paralelamente, la función "devolvería" el código de salida de gpg(GnuPG). Piense en el código de salida como un bono que otros idiomas no tienen o, dependiendo de su temperamento, como un "Schmutzeffekt" de funciones de shell. Este estado es, por convención, 0 en caso de éxito o un número entero en el rango 1-255 para otra cosa. Para aclarar esto: return(like exit) solo puede tomar un valor de 0-255, y los valores distintos de 0 no son necesariamente errores, como se afirma a menudo.

Cuando no proporciona un valor explícito, returnel estado se toma del último comando en una declaración / función / comando Bash, etc. Por lo tanto, siempre hay un estado y returnes solo una forma fácil de proporcionarlo.

La returninstrucción establece el código de salida de la función, muy similar a lo exitque hará para todo el script.

El código de salida para el último comando siempre está disponible en la $?variable.

function fun1(){
  return 34
}

function fun2(){
  local res=$(fun1)
  echo $? # <-- Always echos 0 since the 'local' command passes.

  res=$(fun1)
  echo $?  #<-- Outputs 34
}

El problema con otras respuestas es que usan un global, que puede sobrescribirse cuando hay varias funciones en una cadena de llamadas, o echoque su función no puede generar información de diagnóstico (olvidará que su función hace esto y el "resultado", es decir, devuelve valor, contendrá más información de la que espera la persona que llama, lo que provocará un error extraño), o evalque es demasiado pesado y hacky.

La forma correcta de hacer esto es poner las cosas de nivel superior en una función y usar una localregla de alcance dinámico de bash. Ejemplo:

func1() 
{
    ret_val=hi
}

func2()
{
    ret_val=bye
}

func3()
{
    local ret_val=nothing
    echo $ret_val
    func1
    echo $ret_val
    func2
    echo $ret_val
}

func3

Esto salidas

nothing
hi
bye

¡El alcance dinámico significa que ret_valapunta a un objeto diferente dependiendo de la persona que llama! Esto es diferente del alcance léxico, que es lo que usan la mayoría de los lenguajes de programación. Esta es en realidad una característica documentada , fácil de pasar por alto, y no muy bien explicada, aquí está la documentación para ello (el énfasis es mío):

Las variables locales a la función pueden declararse con el local incorporado. Estas variables son visibles solo para la función y los comandos que invoca .

Para alguien con un fondo C / C ++ / Python / Java / C # / javascript, este es probablemente el mayor obstáculo: las funciones en bash no son funciones, son comandos y se comportan como tales: pueden generar stdout/ stderrpueden conectarse / out, pueden devolver un código de salida. Básicamente no hay diferencia entre definir un comando en un script y crear un ejecutable al que se pueda llamar desde la línea de comando.

Entonces, en lugar de escribir su script de esta manera:

top-level code 
bunch of functions
more top-level code

escríbelo así:

# define your main, containing all top-level code
main() 
bunch of functions
# call main
main  

donde main()declara ret_valcomo localy todas las demás funciones devuelven valores a través de ret_val.

Consulte también la siguiente pregunta de Unix y Linux: Alcance de las variables locales en las funciones de Shell .

Otra solución, quizás incluso mejor según la situación, es la publicada por ya.teck que utiliza local -n.

Otra forma de lograr esto son las referencias de nombre (requiere Bash 4.3+).

function example {
  local -n VAR=$1
  VAR=foo
}

example RESULT
echo $RESULT

Me gusta hacer lo siguiente si se ejecuta en un script donde se define la función:

POINTER= # used for function return values

my_function() {
    # do stuff
    POINTER="my_function_return"
}

my_other_function() {
    # do stuff
    POINTER="my_other_function_return"
}

my_function
RESULT="$POINTER"

my_other_function
RESULT="$POINTER"

Me gusta esto, porque puedo incluir declaraciones de eco en mis funciones si quiero

my_function() {
    echo "-> my_function()"
    # do stuff
    POINTER="my_function_return"
    echo "<- my_function. $POINTER"
}

Como complemento de las excelentes publicaciones de otros, aquí hay un artículo que resume estas técnicas:

• establecer una variable global
• establecer una variable global, cuyo nombre le pasó a la función
• establece el código de retorno (y recógelo con $?)
• 'echo' algunos datos (y recógelos con MYVAR = $ (myfunction))

Valores devueltos de funciones bash

Git Bash en Windows usando matrices para múltiples valores de retorno

CODIGO BASH:

#!/bin/bash

##A 6-element array used for returning
##values from functions:
declare -a RET_ARR
RET_ARR[0]="A"
RET_ARR[1]="B"
RET_ARR[2]="C"
RET_ARR[3]="D"
RET_ARR[4]="E"
RET_ARR[5]="F"


function FN_MULTIPLE_RETURN_VALUES(){

   ##give the positional arguments/inputs
   ##$1 and $2 some sensible names:
   local out_dex_1="$1" ##output index
   local out_dex_2="$2" ##output index

   ##Echo for debugging:
   echo "running: FN_MULTIPLE_RETURN_VALUES"

   ##Here: Calculate output values:
   local op_var_1="Hello"
   local op_var_2="World"

   ##set the return values:
   RET_ARR[ $out_dex_1 ]=$op_var_1
   RET_ARR[ $out_dex_2 ]=$op_var_2
}


echo "FN_MULTIPLE_RETURN_VALUES EXAMPLES:"
echo "-------------------------------------------"
fn="FN_MULTIPLE_RETURN_VALUES"
out_dex_a=0
out_dex_b=1
eval $fn $out_dex_a $out_dex_b  ##<--Call function
a=${RET_ARR[0]} && echo "RET_ARR[0]: $a "
b=${RET_ARR[1]} && echo "RET_ARR[1]: $b "
echo
##----------------------------------------------##
c="2"
d="3"
FN_MULTIPLE_RETURN_VALUES $c $d ##<--Call function
c_res=${RET_ARR[2]} && echo "RET_ARR[2]: $c_res "
d_res=${RET_ARR[3]} && echo "RET_ARR[3]: $d_res "
echo
##----------------------------------------------##
FN_MULTIPLE_RETURN_VALUES 4 5  ##<---Call function
e=${RET_ARR[4]} && echo "RET_ARR[4]: $e "
f=${RET_ARR[5]} && echo "RET_ARR[5]: $f "
echo
##----------------------------------------------##


read -p "Press Enter To Exit:"

RENDIMIENTO ESPERADO:

FN_MULTIPLE_RETURN_VALUES EXAMPLES:
-------------------------------------------
running: FN_MULTIPLE_RETURN_VALUES
RET_ARR[0]: Hello
RET_ARR[1]: World

running: FN_MULTIPLE_RETURN_VALUES
RET_ARR[2]: Hello
RET_ARR[3]: World

running: FN_MULTIPLE_RETURN_VALUES
RET_ARR[4]: Hello
RET_ARR[5]: World

Press Enter To Exit: