Tips and Tricks to use Unshift in Bash with Examples

Shell Scripting

Introduction to Unshift in Bash

Bash, as a powerful scripting language, allows for a variety of array manipulations. However, it’s essential to note that Bash does not natively support the unshift operation, which is commonly used in other programming languages like JavaScript. The unshift operation is instrumental in array manipulation, primarily when there’s a need to add an element at the beginning of an array, effectively pushing the other elements one position forward.

Despite Bash lacking built-in support for the unshift operation, it is still achievable with a bit of creativity and command mastery. One can simulate the unshift operation by utilizing various shell commands and scripting techniques, ensuring that array manipulations can be as flexible and dynamic as in other robust programming languages. This adaptation allows Bash users to manage arrays effectively, emphasizing the language's flexibility and adaptability.


What is unshift in Bash and how is it different from shift?

Unshift in Bash

"Unshifting" means adding an element at the beginning of a list or array. Bash doesn't have a built-in "unshift" command, but you can simulate it.

Example: Imagine you have a line of people, and you want to add someone to the front of the line.

# You have a line of people represented as an array
people=("Alice" "Bob" "Carol")

# You want to add "Dave" to the front of the line
people=("Dave" "${people[@]}")

Now, the people array looks like this: ("Dave" "Alice" "Bob" "Carol").


Shift in Bash

Shifting" means removing the first element from a list or array, or from the input arguments in a script. Bash has a built-in shift command that does this.

Example: Continuing with our line of people, you want the first person ("Dave") to leave the line.

# You have a line of people
people=("Dave" "Alice" "Bob" "Carol")

# Dave leaves the line
shift people

Now, the people array looks like this: ("Alice" "Bob" "Carol").

Differences Between Unshifting and Shifting


  • Unshifting adds an element at the start.
  • Shifting removes the first element.


  • Unshifting increases the size of the array.
  • Shifting decreases the size of the array.


Simulating the Unshift Operation in Bash

Performing Unshift Operation on Bash Arrays

Even though Bash doesn’t have a built-in unshift command, you can still achieve this operation manually by adding elements at the beginning of an array. Here’s a step-by-step guide on how to do this:

1. Declaring an Array

First, declare an array to work with.

array=("element1" "element2" "element3")

2. Prepending a New Element

To prepend a new element, you can use the following method:

array=("new_element" "${array[@]}")

In this command:

  • "new_element" is the value you want to add at the beginning of the array.
  • "${array[@]}" represents all the existing elements of the array.

3. Verifying the Operation

To ensure that the element has been added at the beginning of the array, you can print the array:

echo "${array[@]}"

Here’s a practical example to clarify the process:

# Declaring the array
array=("apple" "banana" "cherry")
echo "Original array: ${array[@]}"

# Simulating the unshift operation
array=("orange" "${array[@]}")
echo "Modified array: ${array[@]}"


Original array: apple banana cherry
Modified array: orange apple banana cherry

In this example:

  • An array of fruits is declared initially.
  • A new element, "orange", is prepended to the array, simulating the unshift operation.
  • Both the original and modified arrays are printed out to verify that the new element has been correctly added at the beginning.


Performing Unshift Operation on Input Arguments

Here is how you can achieve unshift operation on Bash input arguments:

  1. Accessing the Input Arguments: You can access the input arguments using $1, $2, $3, and so on.
  2. Prepending a New Argument: To prepend a new argument, you can set it as $1.
  3. Shifting the Other Arguments: The other arguments can be shifted manually to make room for the new argument.
  4. Verifying the Operation: You can echo the arguments to ensure they have been shifted correctly.

Here’s a bash script example demonstrating this:


# Printing original arguments
echo "Original arguments: $@"

# Simulating the unshift operation
set -- "new_arg" "$@"

# Printing modified arguments
echo "Modified arguments: $@"

You can run the script and pass some arguments:

bash arg1 arg2 arg3


Original arguments: arg1 arg2 arg3
Modified arguments: new_arg arg1 arg2 arg3

In this example:

  • The script first prints the original arguments.
  • The set command is used to prepend a new argument, simulating the unshift operation.
  • Finally, the script prints the modified list of arguments to verify that the new argument has been correctly added at the beginning.


Processing Multiple Arguments with Shift and Simulated Unshift

Below is an example using a while loop to process multiple arguments and demonstrating the use of shift and simulated unshift.


# Function to simulate unshift operation
unshift() {
    set -- "$1" "${@:3}"

# Printing original arguments
echo "Original arguments: $@"

# Using a while loop to process arguments
while [ "$#" -gt 0 ]; do
    case $1 in
            echo "Unshifting: $new_arg"
            unshift "$new_arg" "$@"
            echo "Current arguments: $@"
            echo "Shifting..."
            echo "Unknown option: $1"

You can run the script and pass some arguments:

bash -a arg1 -p -a arg2 -p -s -p


  • This script processes command-line arguments with options -a (add), -p (print), and -s (shift).
  • The unshift() function is used to simulate the unshift operation by adding a new element at the beginning of the argument list.
  • The while loop processes each argument one by one.
  • The case statement inside the loop allows for different actions based on the argument:
    • -a|--add simulates the unshift operation by adding a new argument at the beginning.
    • -p|--print prints the current list of arguments.
    • -s|--shift performs the shift operation, removing the first argument.


Code Examples of Unshift Operation

Example 1: Unshifting a Single Element


# Original array
array=("A" "B" "C")
echo "Original array: ${array[@]}"

# Unshifting operation
array=("$element" "${array[@]}")
echo "Array after unshifting \"$element\": ${array[@]}"


  • A basic array with elements "A", "B", and "C" is created.
  • A new element "X" is prepended at the beginning of the array.
  • The modified array is then printed to show the updated elements.

Example 2: Unshifting Multiple Elements


# Original array
array=("1" "2" "3")
echo "Original array: ${array[@]}"

# Unshifting operation
new_elements=("X" "Y" "Z")
array=("${new_elements[@]}" "${array[@]}")
echo "Array after unshifting \"${new_elements[@]}\": ${array[@]}"


  • An array with numeric elements is initially declared.
  • Multiple new elements "X", "Y", and "Z" are prepended at the beginning.
  • The updated array is printed to visualize the changes.

Example 3: Unshifting in Command-line Arguments


# Function to simulate unshift operation
unshift() {
    set -- "$1" "${@:3}"

# Using unshift in command-line arguments
unshift "New_Arg" "$@"
echo "Arguments after unshifting: $@"


  • A function unshift is defined to manipulate command-line arguments.
  • A new argument "New_Arg" is prepended to the existing list of arguments.
  • Modified arguments are printed to verify the unshift operation.


Comparison with Other Array Operations in Bash

Let's explore how the unshift operation compares with other array operations like shift, push, and pop in Bash:

Unshift vs. Shift

  • Unshift: This operation involves adding an element at the beginning of an array, essentially pushing the existing elements one position forward.
  • Shift: In contrast, the shift operation removes the first element from the array or positional parameters, causing the remaining elements to move one position backward.

Unshift vs. Push

  • Unshift: As previously described, unshift prepends an element to the array.
  • Push: The push operation, or array appending, involves adding an element at the end of an array, expanding its size.

Unshift vs. Pop

  • Unshift: It involves adding elements at the start of an array.
  • Pop: The pop operation isn't directly supported in Bash, but it typically involves removing and returning the last element from an array, reducing its size.


Frequently Asked Questions (FAQs)

Why doesn’t Bash natively support the unshift operation?

Bash, being a shell scripting language, has certain limitations and doesn't natively support all array operations found in more extensive programming languages. However, Bash provides enough flexibility through various commands and scripting techniques to simulate the unshift operation.

Can the unshift operation be performed on positional parameters in bash scripts?

Yes, you can simulate the unshift operation on positional parameters in a bash script by manually manipulating the $1, $2, $3,... variables, using the set command, or by creatively using array operations.

Is it possible to unshift multiple elements at once in Bash?

Yes, you can unshift multiple elements by grouping them together, typically within parentheses, and then prepending them to the existing array or list of positional parameters.

How does unshift affect the index of array elements in Bash?

The unshift operation effectively pushes the existing elements one or more positions forward, based on how many new elements are being added. The index of the existing elements increases, making room for the new elements at the beginning of the array.

What are some common use cases where the unshift operation might be helpful in bash scripting?

Unshift can be particularly useful in scenarios such as managing queues, preprocessing data, manipulating command-line arguments, managing log files, and setting priorities in configuration lists, among others.



In our exploration of the "unshift" operation in Bash, we delved into various essential aspects to build a comprehensive understanding. We began with an introduction, clarifying that Bash natively doesn't support the unshift operation but can be achieved manually. The unshift operation essentially involves adding elements at the beginning of an array or list, contrary to the shift operation which removes them.

Through detailed code examples, we illustrated how to manually simulate the unshift operation, whether in arrays or input arguments. We discussed the application of unshift in practical scenarios, emphasizing its utility in data manipulation, queue management, and enhancing script functionality. Additionally, we compared unshift with other array operations such as shift, push, and pop, highlighting its uniqueness in modifying arrays.

You may refer to the GNU Bash manual to learn more about Bash Scripting:


Views: 57
Deepak Prasad

Deepak Prasad

He is the founder of GoLinuxCloud and brings over a decade of expertise in Linux, Python, Go, Laravel, DevOps, Kubernetes, Git, Shell scripting, OpenShift, AWS, Networking, and Security. With extensive experience, he excels in various domains, from development to DevOps, Networking, and Security, ensuring robust and efficient solutions for diverse projects. You can connect with him on his LinkedIn profile.

Can't find what you're searching for? Let us assist you.

Enter your query below, and we'll provide instant results tailored to your needs.

If my articles on GoLinuxCloud has helped you, kindly consider buying me a coffee as a token of appreciation.

Buy GoLinuxCloud a Coffee

For any other feedbacks or questions you can send mail to

Thank You for your support!!