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:


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

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

Firstly,declare -a array declares a global variable “array” using the declare command and the -a option indicates that the variable “array” is an indexed array. After that, a function named get_array is defined. Inside the function, array=("apple" "banana" "orange" "cherry") assigns the four elements to the variable “array”. When the function is called, echo "${array[0]}" prints the 1st element of the array. Similarly, “${array[1]}” “${array[2]}” “${array[3]}” are used to print 2nd, 3rd, and 4th array element.

returns array elements from function using global variable

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

Note: You can print the entire array in one line by placing the echo "${array[@]}" line after the function call.

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:


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

# Call the function and capture its output using command substitution

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

Inside the return_array function, a local variable “array” with values (1 2 3 4 5 6) is declared first. Then a for loop iterates over each array element and prints them separately using echo "$element".  After that, result=$(return_array) uses command substitution to capture the function’s output. Finally, echo "$result" displays the captured output.

returns array elements from function using command substitution

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:


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

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

In this script, the get_array function includes an array with 4 elements (“apple” “banana” “orange” “cherry”). The for loop iterates over the array elements and shows each array in the terminal using the echo command. Later, result=$(< <(get_array)) uses the process substitution approach to catch the function’s output and print it on the console with echo "$result".

returns array elements from function using process substitution

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:


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

IFS=' '
 for element in "${individual_elements[@]}"; do
  echo "$element"

This Bash script first defines a function called return_array that creates a local array variable named “array” containing integers from 1 to 6. echo "${array[@]}" echoes all the array elements separated by spaces.

The script then captures the output of the return_array function into a variable “array” using command substitution. Afterward, individual_elements=($array) splits the “array” into individual elements using the IFS value.

Finally, it iterates over each element of the “individual_elements” array using a for loop and prints each element of the “individual_elements” array.

returns array elements from function using IFS

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:


# 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"

Inside the get_array function, local -n array=$1 declares a local variable “array” and the -n option makes it a nameref. This nameref is then assigned the value of the first argument ($1) provided to the function. This means that the “array” which contains 4 elements (“apple” “banana” “orange” “cherry”) becomes a reference to the array passed to the function.

After that, declare -a result_array declares a “result_array” that holds the result returned by the “get_array” function. Consequently, get_array result_array calls the get_array function and passes “result_array” as an argument, allowing “get_array” to modify the “result_array” directly via the nameref. Lastly, the for loop iterates over the array elements and prints them in the terminal.

returns array elements from function using nameref

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:


# Function that uses a here-document to return an array
function return_array {
 cat <<EOF

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

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

In this script, the return_array function uses the cat command to display the content within the delimiter EOF…EOF. Then, mapfile -t my_array < <(return_array) captures the output of the function and converts the text into an array. Here, the -t option removes trailing newline characters from each line read. Lastly, echo "Array elements: ${my_array[@]}" prints out all the elements of the “my_array” array.

returns array elements from function using here-document

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:


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


The get_array function contains a local variable “array” which has 4 elements. After calling the function, printf "%s\n" "${array[@]}" prints all the array elements on a separate line in the terminal.

returns array elements from function using printf command

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


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:


# Define a function to populate an associative array
populate_array() {
 local -n array_ref=$1  # Create a reference to the array passed as argument

# 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

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

Rate this post
A Complete Guide for Beginners Enroll Course Now
icon linux
Mitu Akter Mou

Hello, This is Mitu Akter Mou, currently working as a Linux Content Developer Executive at SOFTEKO for the Linuxsimply project. I hold a bachelor's degree in Biomedical Engineering from Khulna University of Engineering & Technology (KUET). Experiencing new stuff and gathering insights from them seems very happening to me. My goal here is to simplify the life of Linux users by making creative articles, blogs, and video content for all of them. Read Full Bio

Leave a Comment