Arrays in Bash Scripting - In the last article about Shell Scripting, we learned about variables and their types - Normal variables, Shell variables and Environment variables. These variables are known as 'Scalar Variables', as they can hold only a single value. Bash comes with another type of variables, those have ability to hold multiple values, either of a same type or different types, known as 'Array'. Rather than creating a separate variable for each value to be stored, Array variable allows the programmer to use only one variable to hold multiple values, at the same time. There is no maximum limit for the Array Size and no such compulsion to store the values in contiguous manner. In this article, we will learn how arrays can be defined, how they can be used and some basic operations which we can perform on them.
Initializing the Arrays
As we've seen in our article on variables, to declare a variable, we need a name, a value and the assignment (
='
) operator to assign that value to the variable.Syntax:
varName=Value
Example:
myName="Mandar" myAge=27
As quoted above, we can use a single Array variable to store multiple values. In the simplest method for storing a value in any Array variable, we need name of the array and an index. If you are familiar with C Language (or any other programming language, I must say), you will be aware of initializing arrays, which looks more like follows:
Syntax:
arrayName[index]=Value
Note: First element of any array will be it index '0', i.e. arrayName[0] will be the first element of the arrayName.
Example:
Fruits[0]="Apple" Fruits[1]="Mango" Fruits[2]="Orange" Fruits[3]="Banana"
This certainly is not the way one would prefer to use. We can create an array by puting its elements within parenthesis and assigning it to a variable as shown below:
Syntax:
arrayName=(Value1 Value2 Value3 ... ValueN)
Example:
Fruits=(Apple Mango Orange Banana)
Another way is to use
declare
construct as below. This is similar to the above case, but uses declare
construct.Syntax:
declare -a arrayName=(Value1 Value2 Value3 ... ValueN)
Example:
declare -a Fruits=(Apple Mango Orange Banana)
Indexing
Each element in the array is associated with a positional parameter, called Index, using which it can easily be accessed. The first element of the array has the index '0', while the last element of the array containing 'n' elements, has the index 'n-1'. The array elements can be read from the array using their indices as shown below:
Syntax:
${arrName[index]}
Example:
#1st Element in Array 'Fruits' ${Fruits[0]} #2nd Element in Array 'Fruits' ${Fruits[1]} #3rd Element in Array 'Fruits' ${Fruits[2]} #4th Element in Array 'Fruits' ${Fruits[3]}
Note: The braces are required to avoid conflicts with path name expansion.
Printing Array
In above section, we saw how an individual element can be extracted from an array. But, we haven't seen how all the elements can be displayed on the terminal screen. We use
*
and @
as follows:Syntax:
${arrName[@]} OR ${arrName[*]}
Example:
${Fruits[@]} OR ${Fruits[*]}
Let us verify this by running the following script:
#!/bin/bash Fruits=(Apple Mango Orange Banana) echo "${Fruits[@]}"
Result:
Apple Mango Orange Banana
Length of Array and Size of Array Elements
When using arrays, one must know how many elements are present in the array. No, you need not count them all. Instead, bash provides a special operator who does all the work for us. We can display the length of the whole array or any array element by using a special operator '#'. Here, length of an array will be displayed in terms of number of elements present in it whereas size of an array element will be in terms of number of characters in that element.
Syntax:
#Length of arrayName = No. of elements present in arrayName ${#ArrayName[@]} #Length of arrayName[index] = No. of characters in arrayName[index] ${#arrayName[index]}
Example:
# Length of Fruits = No. of elements present in "Fruits" ${#Fruits[@]} # Size of Fruits[1] = No. of characters in "Mango" ${#Fruits[1]}
Let's verify this by writing a script:
#!/bin/bash Fruits=(Apple Mango Orange Banana) echo "Length of 'Fruits' = ${#Fruits[@]}" echo "Length of 'Fruits[1]' = ${#Fruits[1]}"
Result:
Length of 'Fruits' = 4 Length of 'Fruits[1]' = 5
Slicing arrays
With Slicing, we can extract a portion from an array (sub-array). For this, we need to provide
START
index, from where slice should begin, and Number
, indicating how many elements should be fetched. Lets take a look at an example.#!/bin/bash Fruits=(Apple Mango Orange Banana Grapes Watermelon); echo ${Fruits[@]:2:3}
In above example, slicing will begin from the element at index 2. It will fetch 3 elements from the array, meaning that next two elements (index 3 and index 4) will be fetched from the
Fruits
array.Result:
Orange Banana Grapes
Similarly, we can slice characters from an array element, as shown below:
#!/bin/bash Fruits=(Apple Mango Orange Banana Grapes Watermelon); echo ${Fruits[4]:2:3}
In above example, we intend to work on element at index 4 in
Fruits
array and extract 3 characters starting from the one at index 2. Here, the element is Grapes
and slice will get us ape
.Result:
ape
Search an Element and Get it replaced
One can also search for an element in already declared array and replace it by a different value. The syntax for this is -
Syntax:
${ArrayName[@]/Search/Replacement}
Example:
#!/bin/bash Fruits=(Apple Mango Orange Banana Grapes Watermelon); echo ${Fruits[@]/Grapes/Strawberry}
In above example, we search for the element
Grapes
in the array Fruits
, replace it with Strawberry
and print the updated Fruits
array.Result:
Apple Mango Orange Banana Strawberry Watermelon
Copy of an Array
As we know, we can access the entire array using
${ArrayName[@]}
. When we put it within parenthesis, we get a copy of the same array, which can be saved in another variable.Syntax:
arrayName1=(Value1 Value2 Value3 .. ValueN) arrayName2=("${arrayName1[@]}")
Example:
#!/bin/bash Fruits=(Apple Mango Orange Banana) myFavFruits=("${Fruits[@]}") echo ${myFavFruits[@]}
Result:
Apple Mango Orange Banana
Concatenation of Arrays
Another important operation we can perform on arrays is Concatenation. With this, we can add an array with another array, to get a combined version of the arrays. For this, we can put two arrays, side-by-side, within the parenthesis.
Syntax:
arrayName1=(value1 value2 value3 .. valueN) arrayName2=(VALUE1 VALUE2 VALUE3 .. VALUEn) newArray=("${arrayName1[@]}" "${arrayName2[@]}")
Example:
#!/bin/bash Linux=(Ubuntu LinuxMint CentOS Fedora) Windows=(WinXP Win7 Win8) LinWin=("${Linux[@]}" "${Windows[@]}") echo ${LinWin[@]}
Result:
Ubuntu LinuxMint CentOS Fedora WinXP Win7 Win8
Adding Elements to the Array
Now, we have two new fruits -
Blackberry
and Blueberry
, to be added to the Fruits
basket. We can add them to the array Fruits
in somewhat similar manner, we saw earlier. Just access all the array elements as ${ArrayName[@]}
and elements to be added, and include them all within parenthesis.#!/bin/bash Fruits=(Apple Mango Orange Banana Grapes Watermelon); Fruits=(${Fruits[@]} Blackberry Blueberry) echo "${Fruits[@]}"
Result:
Apple Mango Orange Banana Grapes Watermelon Blackberry Blueberry
Removing an Element From an Array
To remove an element completely from an array completely, we need to merge two sub-arrays: First sub-array will consist of all those elements present before the element to be removed and Second sub-array will contain all those elements arriving after the element to be removed. Let us consider that, we have to remove 'Banana' present at index 3 in 'Fruits' array.
#!/bin/bash Fruits=(Apple Mango Orange Banana Grapes Watermelon Blackberry Blueberry) idx=3 Fruits=(${Fruits[@]:0:$idx} ${Fruits[@]:$(expr $idx + 1)}) echo "${Fruits[@]}"
In above script,
${Fruits[@]:0:$idx}
fetches 3 elements starting from index 0, i.e. Fruits[0]
, Fruits[1]
and Fruits[2]
, and ${Fruits[@]:$(expr $idx + 1)}
extracts all the elements from index 4 to the last index. These two sub-arrays are merged to create a new Fruits array, which does not contain
Banana
.Result:
Apple Mango Orange Grapes Watermelon Blackberry Blueberry
Another alternative to remove an element from an array is to assign a 'null' value to the element. You can assign a null value to an element using 'unset' as follows:
#!/bin/bash Fruits=(Apple Mango Orange Banana Grapes Watermelon Blackberry Blueberry) unset Fruits[3] echo "${Fruits[@]}"
Result:
Apple Mango Orange Grapes Watermelon Blackberry Blueberry
The difference in both these techniques to remove an element from an array will be observed when you add following line in the script:
echo "${Fruits[3]}"
If you use first method to remove the element from the array, above line will show you 'Grapes' in the result. If you use 'unset', then it will display null value which was assigned to the concerned element.
You can also remove an array element using patterns as shown in following script:
#!/bin/bash Fruits=(Apple Mango Orange Banana Grapes Watermelon Blackberry Blueberry) Fruits2=(${Fruits[@]/Ban*/}) echo "${Fruits2[@]}"
To delete an entire array, you can use
unset
in the script as follows:unset arrayName
So, we have reached the end of this article. Please share your views and feedback in the comment section below and stay tuned. Thank you.
0 comments:
Post a Comment