Styjun

$(...) captures the text sent to stdout by the command contained within. return does not output to stdout. $? contains the result code of the last command.

fun1 ()
 return 34


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

Functions in Bash are not functions like in other language; they're actually commands. So functions are used as if they were binaries or scripts fetched from your path. From the perspective of your program logic there should be really no difference.

Shell commands are connected by pipes (aka streams), and not fundamental or user-defined data types, as in "real" programming languages. There is no such thing like a return value for a command, maybe mostly because there's no real way to declare it. It could occur on the man-page, or the --help output of the command, but both are only human-readable and hence are written to the wind.

When a command wants to get input it reads it from its input stream, or the argument list. In both cases text strings have to be parsed.

When a command wants to return something it has to echo it to its output stream. Another oftenly practiced way is to store the return value in dedicated, global variables. Writing to the output stream is clearer and more flexible, because it can take also binary data. For example, you can return a BLOB easily:

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

As others have written in this thread, the caller can also use command substitution $() to capture the output.

Parallely, the function would "return" the exit code of gpg (GnuPG). Think of the exit code as a bonus that other languages don't have, or, depending on your temperament, as a "Schmutzeffekt" of shell functions. This status is, by convention, 0 on success or an integer in the range 1-255 for something else. To make this clear: return (like exit) can only take a value from 0-255, and values other than 0 are not necessarily errors, as is often asserted.

When you don't provide an explicit value with return the status is taken from the last command in a Bash statement/function/command and so forth. So there is always a status, and return is just an easy way to provide it.

The return statement sets the exit code of the function, much the same as exit will do for the entire script.

The exit code for the last command is always available in the $? variable.

function fun1()
 return 34


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

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

I like to do the following if running in a script where the function is defined:

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"

I like this, becase I can then include echo statements in my functions if I want

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

Another way to achive this is name references (requires Bash 4.3+).

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


example RESULT
echo $RESULT

The problem with other answers is they either use a global, which can be overwritten when several functions are in a call chain, or echo which means your function cannot output diagnostic info (you will forget your function does this and the "result", ie return value, will contain more info than your caller expects, leading to weird bug), or eval which is way heavy and hacky.

The proper way to do this is to put the top level stuff in a function and use a local with bash's dynamic scoping rule. Example:

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

This outputs

nothing
hi
bye

Dynamic scoping means that ret_val points to a different object depending on the caller! This is different from lexical scoping, which is what most programming languages use. This is actually a documented feature, just easy to miss, and not very well explained, here is the docs for it (emphasis is mine):

Variables local to the function may be declared with the local
builtin. These variables are visible only to the function and the
commands it invokes.

For someone with a C/C++/Python/Java/C#/javascript background, this is probably the biggest hurdle: functions in bash are not functions, they are commands, and behave as such: they can output to stdout/stderr, they can pipe in/out, they can return an exit code. Basically there is no difference between defining a command in a script and creating an executable that can be called from the command.

So instead of writing your script like this:

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

write it like this:

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

where main() declares ret_val as local and all other functions return values via ret_val.

See also https://unix.stackexchange.com/questions/282557/scope-of-local-variables-in-shell-functions.

Another, perhaps even better solution depending on situation, is the one posted by ya.teck which uses local -n.

As an add-on to others' excellent posts, here's an article summarizing these techniques:

• set a global variable


• set a global variable, whose name you passed to the function


• set the return code (and pick it up with $?)


• 'echo' some data (and pick it up with MYVAR=$(myfunction) )

Returning Values from Bash Functions

Git Bash on Windows using arrays for multiple return values

BASH CODE:

#!/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:"

EXPECTED OUTPUT:

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: