How to Get the Length of an Array in Bash? [Complete Guide]

You can use the following methods to determine the length of an array in Bash:

  1. Using Length Expression ${#array[@]}:
    echo "${#your_array[@]}"
  2. Using “for Loop”:
    array_length=0   # Initialize a variable to store the array length
    
    #iterate and fetch the array length
    for element in "${array[@]}"; do 
        ((array_length++))
    done

The length of an array in Bash is the total number of elements present in the array. Understanding array length is crucial considering the operations such as array iteration including working with each element. This article discusses several methods on how to get the array length in Bash. It mentions basic techniques using the standard length expressions to advanced techniques using commands and Bash loops to measure the array length in Bash. Additionally, it discusses the essential concept of array size including array length with their distinctive attributes.

What is Array Length and Array Size in Bash?

You must have heard the terms array length and array size used from time to time by the coders and developers. Although they seem to have the same meaning, the terms have a rudimentary distinction that I will mention below using their standard definition:

1. Array Length in Bash: In the context of arrays, the attribute length determines the number of elements the array contains. It is the most pertinent metric that lets you know how many items the array currently has and is often used in looping tasks for specified data-managing goal accomplishment. Now, look at the array mentioned below:

hello_reader=("harryPotter" "greatGatsby" "vinciCode")

The length of the array hello_reader is 3. Isn’t it obvious?

 2. Array Size in Bash: The array size represents the memory/storage space allocated to that array. It makes more sense in programming languages such as C and C++, where the manual allocation/deallocation of memory is a must.

Note: Due to its vibrant nature, array length in Bash is more prevalent in typical scripting scenarios.

6 Methods to Get the Length of a Bash Indexed Array

You can get the length of an indexed array in Bash by employing several user-friendly methods. In this section, I will guide you through 6 effective methods (using length expressions, commands, and loops) to print the length of an indexed array via Bash scripting.

1. Using the Expression Syntax ${#array[@]} and ${#array[*]}

The two length expressions ${#array[@]} and${#array[*]} in Bash with the echo command as the prefix seamlessly get the array length. Let’s look at the full syntax:

Syntax 01:

echo ${#array[@]}

Syntax 02:

echo ${#array[*]}
EXPLANATION
  • echo: Bash command used to set the array variable attribute.
  • ${ }: Used to retrieve the value of a variable.
  • array_name: The name of the array you want to assign.
  • [@] or [*]: Points out the referencing of all elements of the array.

Here’s an example to print an array length in Bash using the syntax echo ${#array[@]} and echo ${#array[*]}:

#!/bin/bash
#Array creation

metallica =(unforgiven1 unforgiven2 unforgiven3 )

#Array length calculation and assign to a new two variables named length and len

length=${#metallica[@]}

len=${#metallica[*]}

#printing array length to the terminal using both expressions

echo “the array length using \${#metallica[@]}: $length”

echo               # for adding extra spaces between the outputs

echo “the array length using \${#metallica[*]}: $len”
EXPLANATION

In the first line of the getLength_1.sh bash script, #!/bin/bash, #! is called shebang. It indicates the system uses the bash interpreter for executing the script. Then, metallica=(unforgiven1 unforgiven2 unforgiven3) expression creates the array metallica with 3 elements.

After that, the expressions ${#metallica[@]} and ${#metallica[*]}, in consecutive lines, get the array length twice and store the values in the length and len variables afterward. On an end note, the echo command twice prints the length to the prompt followed by the variable names prefixed with $ sign to access the numeric value (3, in this case).

getting indexed array length in bash with expressionsIn the above, I have used the bash script to successfully print the length of the metallica array to the screen by using both expressions.

2. Using the “wc” Command with the expression ${array[@]}

You can use the wc command in a strategic way with the length expression ${array[@]} to get the length of an array in Bash. Below, I have developed a script to show you the practical aspect:

#!/bin/bash

# Array creation
drummers=(vinnie portnoy lars sazu dio)

#printing items
echo "the items: ${drummers[@]}"

#getting length using wc command and assigning variable
arr_len=`echo ${drummers[@]} | wc -w`

#printing the length
echo "The array length is $arr_len"
EXPLANATION

In the above Bash script, drummers=(vinnie portnoy lars sazu dio) creates an array named drummers with 5 values. Then, the echo command prints the elements incorporating the expression ${drummers[@]}. After that, the expression `echo ${drummers[@]} | wc -w` determines the array length. Here, the ${drummers[@]} expression takes all the elements of the array as a single string and pipes to the wc -w command. The -w option counts the number of words (the array elements in this case) and stores the value to the arr_len variable. Finally, the echo command prints the length.

retrieve array length in bash using wc commandSo, in the above snap, you notice that I have printed the array length correctly which is also visible through the printing of the elements.

Note: Remember, the wc command cannot fetch the correct array length when the items are multi-word strings. Refer to the below script for a better perception.

In the following script, I will create an array and fetch the length twice using two methods to show you that the wc command cannot figure out the array length of elements having multi-word strings:

#!/bin/bash

# Array creation with elements that have multiple words
drummers2=("vinnie paul"  "mike portnoy" "lars ulrich" "kazi sazu" "dio haque")

#printing the array elements
echo "the items: ${drummers2[@]}"

echo #to create an extra space in between

#getting length using the wc command and assigning a variable
len=`echo ${drummers2[@]} | wc -w`

#printing the actual length
echo "the actual array length: ${#drummers2[@]}"

echo #to create extra space in between

#printing the wrong length using wc
echo "The array length is using wc: $len"
EXPLANATION

In the aforementioned Bash script, the fourth line creates an array named drummers2 with 5 items (multi-word strings). Following this, the echo command prints the elements of that array to the prompt. After that, the expression `echo ${drummers2[@]} | wc -w` calculates the array length and stores the final value to the len variable. In addition, the ${#drummers2[@]} expression obtains the length of the array. Finally, the echo command operates twice and prints both results.

getting the wrong length with the wc commandIn the aforementioned image, you discern the code gives an output of 10 instead of 5 which is the original array length.

3. Using the “grep” Command with the expression ${array[@]}

Similarly, there’s another command called grep that you can utilize with ${array[@]} to determine the length of a bash array. It is not recommended to use the grep command to get the array length in Bash. However, if you want to adopt this method for some reason, follow the below script namely array_length_grep.sh:

#!/bin/bash

#array creation with 5 elements
arr=("Pushkin" "Tolstoy" "Chekhov" "Gorky" "Turgenev")

#determining and storing the array length into result variable
result=$(echo ${arr[@]} | grep -o " " | grep -c " ")

#necessary checking on the result value before final printing
if [ $result -gt 0 ]
then
   expr $result + 1
else
    if [ ! -z "${arr[0]}" ]
        then
                expr $result + 1
        else
                echo $result
        fi
fi
EXPLANATION

Here, arr=(“Pushkin” “Tolstoy” “Chekhov” “Gorky” “Turgenev”) directly creates an indexed array named arr with 5 elements. Then, the grep command fetches the array length and stores it in the variable result. The detailed view of the expression is below:

      • ${arr[@]}: Expands to all elements in the array as a single string.
      • grep with -o option: Searches for space characters and outputs them individually.
      • second grep with -c option: Counts the occurrences of spaces.
      • result: A variable holding the number of spaces, which is one less than the number of elements in the array.

Now, follow the below steps to complete your understanding of the looping part.

      • First, the script checks if the result (the count of spaces) is greater than 0.
      • Secondly, if the result value is greater than 0, the value is incremented by 1 by the expr $result + 1
      • Then, if the result is not greater than 0, the code checks if the first element of the array (arr[0]) is not empty using [ ! -z “${arr[0]}” ]. If it’s not empty, it uses expr to increment the result by 1.
      • Again, if the first element of the array is empty and the result is not greater than 0, it just prints the original value of the result.
retrieving array length in bash with grep commandThe aforestated screenshot shows that I have successfully printed the array length using the grep command with the assistance of the ${arr[@]} expression.

4. Using “For Loop”

Leveraging Bash for loops to access elements of an indexed array is a fundamental strategy in data handling. In addition, you can smartly utilize this technique to acquire the length of that array.

Here’s an example to find the array length in Bash using for loop:

#!/bin/bash

#create an indexed array with elements
my_array=(1 2 3 4 5)

# Initialize a counter
length=0

# Use a for loop to iterate through the elements
for element in "${my_array[@]}"; do
  ((length++))
done
#printing array elements 
echo "elements: ${my_array[@]}"

#printing array length
echo "length: $length"
EXPLANATION

In this script, my_array=(1 2 3 4 5) command creates an array named my_array with 5 values. Following this, the length variable keeps track of the number of elements. Then, Bash for loop iterates through the entire array using the ${my_array[@]} expression and increments the value of length by 1 for each iteration advancement until all the elements are covered. Finally, the echo command operates twice: 1. To print the elements to show you the number of entries, and 2. To print the length and verify that the code runs without issues and fetches the length correctly.

getting array length using for loopIn the snapshot above, you discern that I have printed the array length using for loop which is evident in the display of the array elements.

Note: Alternatively, you can use the following condition to determine the array length like the script above:
for ((i = 0; i < ${#my_array[@]}; i++)); do
  ((length++))
done

5. Employing “While Loop”

Exploiting the potential of the while loop is a very pragmatic as well as versatile approach toward the determination of the indexed array length in Bash. Let’s see this technique in action via a Bash script:

#!/bin/bash

# Create an indexed array
my_array=("element1" "element2" "element3" "element4")

# Initialize counter for keeping track of the length
length=0

# while loop to iterate through the elements
while [ -n "${my_array[$length]}" ]; do
  ((length++))
done

#print the array length
echo "This is an indexed array with length: $length"
EXPLANATION

In this Bash script, my_array=(“element1” “element2” “element3” “element4”) expression creates an array with 4 items named my_array. After that, the while loop continues as long as it finds elements and increments the length by 1. Here, the length variable tracks the array length. Finally, the echo command prints the array’s length by fetching the value from the $length expression.

get indexed array length with while loopHere, in the aforestated snap, you spot that I have used the while loop to know the length of the array my_array.

6. Using “Until Loop”

Bash scripting provides the users with another loop called the until loop. This is a powerful tool if you can utilize it to its full potential and obtain the length of an indexed array.

Take a look at the script below for clarity on getting Bash array length using until loop:

#!/bin/bash

# Declare an indexed array with 4 values 
hannibal=(lecter will abigail jack)

# Initialize a counter
length=0

# Use an until loop to iterate through the array
until [ -z "${hannibal[$length]}" ]; do
  ((length++))
done

#print the array length
echo "The length of the indexed array is $length"
EXPLANATION

In the above script length_loop3.sh, the command hannibal=(lecter will abigail jack) creates an indexed array hannibal with 4 elements. In addition, the variable length keeps the iteration track using the until loop starting from 0. Now, the until loop continues as long as the given condition is false. In this case, the [ -z “${hannibal[$length]}” ] condition checks if the index represented by the length variable in hannibal array has an empty string and length++ increases the value of length by 1 for iteration advancement. On an end note, the echo command prints the array length to the prompt.

using until loop to get the array length in bashIn this image, I have displayed the printing of the length of the array hannibal using until loop.

Note: The until loop is not very common for retrieving array length. Rather, it’s recommended to use the length expression methods since these are the easiest as well as the most frequently used techniques.

3 Ways to Get the Length of a Bash Associative Array

In a similar manner, getting to know the length of a Bash Associative array is essential in working with data. You can employ 2 methods ( using length expression and loops) for array length calculation which is also the target of this upcoming feature.

1. Using Length Expressions ${#array[@]} and ${#array[*]}

Like the previous scope, you can simply use the length expressions ${#array[@]} and ${#array[*]} to find the length of an associative array in Bash. In associative arrays, the items are stored in key-value pairs and the ${#array[@]} and ${#array[*]} expressions count the number of the key-value pairs which is exactly the length of the specified array.

Follow the script below carefully to understand how to print Bash associative array length:

#!/bin/bash

#crearting an associative array 
declare -A vocals

#populate the array with values
vocals[artcell]=lincoin
vocals[black]=jon
vocals[crypticFate]=shakib
vocals[nemesis]=zohad

#getting the length and storing into variable
length=${#vocals[@]}
len=${#vocals[*]}

#printing array length to the terminal using both expressions
echo "the array length using \${#vocals[@]}: $length"

 # an extra echo command for adding extra spaces between the outputs
echo              

echo “the array length using \${#vocals[*]}: $len”
EXPLANATION

First, declare -A vocals command creates an empty associative array namely vocals with the insertion of 4 values using keys. After that, the length expressions ${#vocals[@]} and ${#vocals[*]}  fetch the length. On a final note, the two variables length and len store the array length and the echo command prints the length twice to the terminal.

getting associative array length with length expressionsIn the above snapshot, I have printed the length (which is 4) of the vocals array without any issues employing both the length expressions.

2. Using “for Loop”

Apart from indexed arrays, the Bash for loop can get the associative array length. That being said, see the below script named assoc_length_loop1.sh to understand the array length retrieving procedure:

#!/bin/bash

#array declare
declare -A places 

#value initialization
places[roll1]=Mostafa
places[roll2]=Das
places[roll3]=Masrur

# Initialize a counter
length=0

# Use a for loop to iterate through the 
for key in "${!places[@]}"; do
  ((length++))
done

#printing the length
echo "length of this associative array is $length"
EXPLANATION

First, the declare -A command declares an associative array named places, and 3 values are initialized afterward. In addition, the variable namely length keeps track of each iteration item for length calculation. After that, the for loop increments the value of length by 1 and it stops when all the array elements are covered. Finally, the echo command prints the value of the variable length to display the length of the places array.

for loop to get associative array lengthIn this above program, I have used for loop to iterate through the array elements and finally print its length.

3. Using “While Loop”

Though not among the popular strategies for acquiring the array length in Bash, you can still make use of the while loop to print the length of an associative array in Bash. Just navigate to the following script:

#!/bin/bash

# Declare an associative array with value initialization
declare -A RSA
RSA["key1"]=kallis
RSA["key2"]=AbD
RSA["key3"]=miller

# Initialize a counter
length=0

# Use a while loop to iterate through the keys
while IFS= read -r key; do
  ((length++))
done < <(printf "%s\n" "${!RSA[@]}")


#printing the length
echo "The length of the associative array is $length"
EXPLANATION

In developing the above Bash script, first, the declare -A RSA command declares an associative array called RSA along with initializing with 3 values using the expression RSA[“key”]=value. Then, the variable length keeps track of the number of elements of the array. After that, the while loop stores the value of the array length to the counter variable length. The step-by-step breakdown of the while loop is:

      • while: The while loop continues till the iterating condition is satisfied.
      • IFS: It sets the Internal Field Separator (IFS) to empty string for preserving leading and trailing spaces.
      • read -r key: This command reads the key from the associative array and stores it in the key
      • length++: Increases the value of the length variable by 1 with each iteration to preserve the array length.
      • (printf “%s\n” “${!RSA[@]}”): Takes the keys and prints on a separate line each.
      • < <: Process substitution taking the output of (printf “%s\n” “${!RSA[@]}”) expression and supplies it as input to the while loop.

Lastly, the echo command prints the value of the final length.

obtaining associative array length using while loopSo, the above image shows that I have fetched the length of the associative array RSA using the while loop.

Note: The method of length expression (${array[@]/[*]}) is the quickest and easiest of the lot.

Conclusion

To sum up, I have tried to provide you with an in-depth analysis of determining array length in Bash employing several hands-on examples. So, after reading this article, you will be able to write efficient code and elevate your script development capability.

People Also Ask

How to find the length of a Bash array?

To find the length of an array in Bash, just use the code ${#array[@]} with the echo command. For example: the full syntax echo ${#array[@]} will return you the length of array to the terminal screen.

Can I store the length of a Bash array into a variable for later use?

Certainly. You can find the length of a Bash array using the expression syntax ${#array[@]} and assign the value to another variable like this: Length=${#array[@]}. In this way, the Length variable will store the array length which you can avail for later use.

Is there any limitation in the size of Bash arrays?

No, Bash arrays are dynamic natured and this lets you work with arrays of unlimited size as there is no maximum limit on the Bash array size.

Is it possible to check if a Bash array is empty?

Yes, it is. Use the code ${#array[@]} to get the length of array, and if it returns 0, then it means that the specified array is empty.

Does Bash have 0-indexed arrays?

Yes, Bash has indexed arrays which are indeed 0-based. This means the first item assignment starts from zero and increases by 1 after every insertion of elements. However, you can assign items at any random index if you want.

What is an array in Bash?

A Bash array is a data structure used to store information in an indexed way. The indexed array in Bash has numbered indices while the associative arrays have string indices called keys.

Can I print the length of a Bash array with null values?

Absolutely. You can use the standard syntax echo ${#array[@]} to get and print the length of the Bash array even if it contains null values. For instance, consider the array fruit_null=("" "apple" "" "banana" ""). If you print its length using echo "${#fruit_null[@]}", it will return 5 as the final output by counting the null elements as valid array elements.

Related Articles


<< Go Back to Bash Array | Bash Scripting Tutorial

Rate this post
LINUX
FUNDAMENTALS
A Complete Guide for Beginners Enroll Course Now
icon linux
Md Masrur Ul Alam

Assalamu Alaikum, I’m Md Masrur Ul Alam, currently working as a Linux OS Content Developer Executive at SOFTEKO. I completed my Bachelor's degree in Electronics and Communication Engineering (ECE)from Khulna University of Engineering & Technology (KUET). With an inquisitive mind, I have always had a keen eye for Science and Technolgy based research and education. I strongly hope this entity leverages the success of my effort in developing engaging yet seasoned content on Linux and contributing to the wealth of technical knowledge. Read Full Bio

Leave a Comment