How to Return Array From Bash Function? [7 Methods]

To return an array from the function in Bash, use the following methods:

1. Using Global Variable: my_function() declare my_array { echo my_array;}
2. Using Command Substitution: variable=$(my_function)
3. Using Process Substitution: variable=$(< <(my_function))
4. Using IFS Variable: IFS=' ' variable=$(my_function)
5. Using “nameref” Feature: my_function() {local -n my_array=$1;} declare ref_array
6. Using Here-document: my_function() {cat EOF my_array EOF;}
7. Using “printf” Command: my_function() {printf "%s\n" "${my_array[@]}";}

Bash does not have a built-in way to return an array directly from the function. Nevertheless, declaring a global variable or using the command substitution method helps to get an array from the bash function. In this article, I will explore 7 methods to seamlessly return arrays from functions in Bash, assisting you to unleash your scripting potential.

1. Using Global Variable

One of the most common approaches to return an array from the function in bash is to define a global variable that can be called from both inside and outside of the function. It offers more simplicity, making the script easy to understand. Here’s a Bash script to return an array using a global variable:

#!/bin/bash

declare -a array
function get_array(){
  array=("apple" "banana" "orange" "cherry")
}

get_array
echo "${array[0]}"
echo "${array[1]}"
echo "${array[2]}"
echo "${array[3]}"

The script returns all the array elements from the function using a global variable.

2. Using Command Substitution

Integrating the command substitution method with the echo command is a straightforward way to catch the output of a function. In this case, the output of the function is an array. Check this script to know how to return an array using the echo command with the command substitution method:

#!/bin/bash

function return_array(){
 local array=(1 2 3 4 5 6)
 for element in "${array[@]}"; do
  echo "$element"
 done
}

# Call the function and capture its output using command substitution
result=$(return_array)

# Print the captured output, with each element on a separate line
echo "$result"

You can see that the function returns each array element using command substitution with the echo command.

3. Using Process Substitution

To gracefully handle the function’s output, consider utilizing the process substitution method with the echo command. This strategy effectively returns the array from a function using the $(< <(function_name)) syntax. Here’s how:

#!/bin/bash

function get_array() {
 local array=("apple" "banana" "orange" "cherry")
 for element in "${array[@]}"; do
  echo "$element"
 done
}

result=$(< <(get_array))
echo "$result"

Returning the array elements from the function smoothly.

4. Using IFS Variable

IFS stands for Internal Field Separator which is a special variable in bash used to split the input string into fields based on the character set to an IFS. In this example, the IFS is set to a single space character that will separate the array into individual elements using space. Afterward, the individual array element will be returned with the help of command substitution and echo command.

Check the full bash script to know how the IFS variable works to return an array from the Bash function:

#!/bin/bash

function return_array(){
 local array=(1 2 3 4 5 6)
 echo "${array[@]}"
}

IFS=' '
array=$(return_array)
individual_elements=($array)
 for element in "${individual_elements[@]}"; do
  echo "$element"
 done

As you can see, the integer values of the array are printed in the terminal.

5. Using “nameref” Feature

Even though Bash cannot directly return arrays from functions, it offers the option to generate a nameref using the -n parameter to manipulate the array directly. Nameref is a useful feature in bash that allows one to create a reference to a variable with another name, where the reference variable behaves like an alias of the original variable. Changes to the reference variable affect the original variable, and vice versa. Check out the script below to return an array using nameref:

#!/bin/bash

# Define function to operate on an array
function get_array {
 local -n array=$1  # Create a nameref
 array=("apple" "banana" "orange" "cherry")  # Use the nameref to assign values
}

# Declare an array to hold the result
declare -a result_array

# Call the function with the reference to the result_array
get_array result_array
for element in "${result_array[@]}"; do
 echo "$element"
done

Upon executing the script, it shows all the elements of the array.

6. Using Here-document

The here-document passes text into a command or script. To return an array from the function using here-doc, incorporate the mapfile command that converts the text of the here-document into an array. Here’s how:

#!/bin/bash

# Function that uses a here-document to return an array
function return_array {
 cat <<EOF
1
2
3
4
5
EOF
}

# Capture the output in an array using mapfile
mapfile -t my_array < <(return_array)

# Access the array
echo "Array elements: ${my_array[@]}"

You can notice that the script has displayed all the array elements.

7. Using “printf” Command

The printf command in Bash prints the text or variables to the standard output. Blending the “printf” command with the function provides a compelling way to return an array from the Bash function. See the following script to accomplish this task:

#!/bin/bash

get_array() {
 local array=("apple" "banana" "orange" "cherry")
 printf "%s\n" "${array[@]}"
}

get_array

Getting the array from the function using the “printf” command.

Conclusion

Returning arrays from Bash functions is a daunting task as Bash does not provide any direct ways to do it. But don’t worry, I have shown you 7 methods that can be used to return an array from a function in bash. Choose the method that works best for you. Good luck!

People Also Ask

Can a Bash function return an array?

Bash function can’t return an array like other programming languages. However, you can simulate the task using a global or IFS variable. Moreover, you can apply command substitution or nameref feature to achieve this task.

How can a function return an array in Bash?

To return an array from a function in bash, create a function named my_function, then define a global variable global_var=(1 2 3 4) containing all the array elements (1 2 3 4). After that, call the function and use echo "${global_var[@]}" to print the array values in the terminal.

Can a function return two arrays?

Yes definitely, a function can return two arrays. To do so, define two arrays as follows: array1=(red blue green) and array2=(apple banana orange), where “array1” and “array2” are the names of the global variables. After that, print the array elements with echo "${array1[@]}" and echo "${array2[@]}".

How to convert array into string in Bash?

To convert an array into a string, you can use parameter expansion that expands each element of the array into separate words. Suppose, a variable named “array” has 3 elements (“This” “is” “Linux”), to make them a string “This is Linux”, use echo "${array[@]}" syntax.

How to return an associative array from Bash function?

An associative array is a collection of key-value pairs where each key is unique within the array. To return an associative array from the function in bash, check the script below:

#!/bin/bash

# Define a function to populate an associative array
populate_array() {
 local -n array_ref=$1  # Create a reference to the array passed as argument
 array_ref["key1"]="value1"
 array_ref["key2"]="value2"
 array_ref["key3"]="value3"
}

# Declare an empty associative array
declare -A my_array

# Call the function to populate the array
populate_array my_array

# Access the elements of the array
echo "Key1: ${my_array["key1"]}"
echo "Key2: ${my_array["key2"]}"
echo "Key3: ${my_array["key3"]}"

Related Articles

• How to Exit From Function in Bash? [5 Ways]
• How to Return Exit status “0” in Bash [6 Cases]
• How to Return String From Bash Function [4 Methods]
• How to Return Boolean From Bash Function [6 Methods]

---

<< Go Back to Return Values From Bash Function | Bash Functions | Bash Scripting Tutorial