Returning Values from Bash Functions

In Bash, functions are used to group a set of commands together to perform a specific task. However, unlike other programming languages, Bash functions do not return values in the classical sense. Instead, they use exit codes and output streams to communicate with the caller.

Understanding Exit Codes

When a Bash function finishes executing, it returns an exit code, which is a value between 0 and 255. This exit code can be used by the caller to determine whether the function executed successfully or not. By convention, an exit code of 0 indicates success, while a non-zero value indicates failure.

To return an exit code from a Bash function, you can use the return statement followed by the desired exit code. For example:

my_function() {
  # Code to be executed
  return 0
}

The caller can then check the exit code using the $? variable:

my_function
if [ $? -eq 0 ]; then
  echo "Function executed successfully"
else
  echo "Function failed with error code $?"
fi

Using Output Streams

Another way for Bash functions to communicate with their caller is through output streams. A function can print its result to the standard output stream using echo, and the caller can capture this output using command substitution ($()).

Here’s an example:

my_function() {
  # Code to be executed
  echo "Hello, World!"
}

result=$(my_function)
echo "$result"

In this example, the my_function function prints its result to the standard output stream, and the caller captures this output using command substitution.

Using Local Variables

Bash also provides a feature called dynamic scoping, which allows functions to access and modify variables from their caller’s scope. This can be useful for returning values from functions without using output streams or exit codes.

Here’s an example:

main() {
  local result
  my_function
  echo "$result"
}

my_function() {
  result="Hello, World!"
}

main

In this example, the my_function function modifies the result variable from the caller’s scope, and the caller can access this modified value.

Using Name References

Bash 4.3 and later versions provide a feature called name references, which allows functions to modify variables from their caller’s scope using a reference.

Here’s an example:

example() {
  local -n var=$1
  var="Hello, World!"
}

result=""
example result
echo "$result"

In this example, the example function modifies the var variable from the caller’s scope using a name reference, and the caller can access this modified value.

Conclusion

Returning values from Bash functions requires a different approach than in other programming languages. By using exit codes, output streams, local variables, or name references, you can write effective and efficient Bash functions that communicate with their callers.