Shifting arguments (shift) in Bash Scripting - Step-by-Step Execution

Concept Flow - Shifting arguments (shift)

Start with all arguments

↓

Use shift command

↓

Remove first argument

↓

Arguments move left

↓

Check if more arguments

↓

Process

The shift command removes the first argument and moves all others left, reducing the argument count by one each time.

Execution Sample

Bash Scripting

echo "$1"
shift
echo "$1"
shift
echo "$1"

Prints the first argument, shifts arguments left, then prints the new first argument twice.

Execution Table

Step	Arguments ($@)	Action	Output
1	arg1 arg2 arg3	Print $1	arg1
2	arg2 arg3	shift (remove arg1)
3	arg2 arg3	Print $1	arg2
4	arg3	shift (remove arg2)
5	arg3	Print $1	arg3
6		No more shifts	End

💡 No more arguments to shift after step 5; script ends.

Variable Tracker

Variable	Start	After shift 1	After shift 2	Final
$@	arg1 arg2 arg3	arg2 arg3	arg3
$1	arg1	arg2	arg3

Key Moments - 2 Insights

Why does $1 change after using shift?

Because shift removes the first argument, the second argument moves to $1, as shown in execution_table steps 2 and 3.

What happens if you shift more times than arguments?

Arguments become empty; $1 is empty. The script stops shifting as no arguments remain, as seen after step 5.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of $1 after the first shift?

A arg2

B arg1

C arg3

D empty

💡 Hint

Check the 'After shift 1' column in variable_tracker for $1.

At which step does the script print 'arg3'?

A Step 3

B Step 2

C Step 5

D Step 1

💡 Hint

Look at the Output column in execution_table for 'arg3'.

If the script started with only two arguments, how many times can shift be used before no arguments remain?

A 1

B 2

C 3

D 0

💡 Hint

Each shift removes one argument; see variable_tracker for argument count changes.

Concept Snapshot

shift command in bash removes the first argument ($1).
All other arguments move left by one position.
$# (argument count) decreases by one.
Use shift to process arguments one by one in scripts.

Full Transcript

This visual trace shows how the bash shift command works. Initially, the script has three arguments: arg1, arg2, and arg3. The script prints the first argument ($1), which is arg1. Then it uses shift to remove arg1. After shifting, arg2 becomes the new $1. The script prints $1 again, showing arg2. Another shift removes arg2, making arg3 the new $1. The script prints $1 once more, showing arg3. After this, no more shifts happen because no arguments remain. The variable tracker shows how $@ and $1 change after each shift. Key moments clarify why $1 changes and what happens if you shift too many times. The quiz tests understanding of $1 values after shifts and how many shifts are possible. The snapshot summarizes that shift removes the first argument and moves others left, reducing the argument count.

Practice

1. What does the shift command do in a bash script?

easy

A. It moves all command-line arguments one position to the left, dropping the first argument.

B. It duplicates the first argument to the end of the list.

C. It reverses the order of all command-line arguments.

D. It prints all command-line arguments without changes.

Solution

1. Step 1: Understand the role of shift

   The shift command removes the first argument and shifts all others left.

2. Step 2: Effect on arguments

   After shift, the second argument becomes the first, the third becomes second, and so on.

3. Final Answer:

   It moves all command-line arguments one position to the left, dropping the first argument. -> Option A

4. Quick Check:

   shift drops first argument [OK]

Hint: Remember: shift drops first argument and moves others left [OK]

Common Mistakes:

• Thinking shift duplicates arguments
• Assuming shift reverses arguments
• Believing shift prints arguments unchanged

2. Which of the following is the correct syntax to shift two arguments in a bash script?

easy

A. shift --2

B. shift -2

C. shift 2

D. shift 1 1

Solution

1. Step 1: Recall shift syntax

   The correct syntax to shift by a number is shift N, where N is a positive integer.

2. Step 2: Identify valid option

   shift 2 shifts by two arguments; negative or multiple numbers are invalid.

3. Final Answer:

   shift 2 -> Option C

4. Quick Check:

   Use shift N with positive N [OK]

Hint: Use 'shift N' with positive number N to shift multiple args [OK]

Common Mistakes:

• Using negative numbers with shift
• Trying to pass multiple numbers
• Using invalid flags like --2

3. What will be the output of this script if run as ./script.sh apple banana cherry?

echo $1
shift
echo $1

medium

A. apple\napple

B. banana\ncherry

C. banana\napple

D. apple\nbanana

Solution

1. Step 1: Check initial $1 value

   Before shift, $1 is the first argument: 'apple'.

2. Step 2: Apply shift and check new $1

   After shift, $1 becomes the second argument: 'banana'.

3. Final Answer:

   apple\nbanana -> Option D

4. Quick Check:

   First echo prints first arg, second echo prints second arg after shift [OK]

Hint: First echo shows $1, shift moves args left, second echo shows new $1 [OK]

Common Mistakes:

• Assuming shift does not change $1
• Confusing argument positions after shift
• Expecting output to be 'banana\ncherry'

4. Identify the error in this script snippet:

shift 3
echo $1

Assuming the script is run with only two arguments.

medium

A. Error: shift 3 tries to shift more arguments than exist, causing an error.

B. No error; it prints the first argument unchanged.

C. Error: shift requires a negative number to work.

D. No error; it prints the third argument.

Solution

1. Step 1: Check number of arguments

   The script has only two arguments but tries to shift by three.

2. Step 2: Understand shift behavior on excess shift

   Shifting more than available arguments causes an error or empties all arguments.

3. Final Answer:

   Error: shift 3 tries to shift more arguments than exist, causing an error. -> Option A

4. Quick Check:

   Shifting beyond argument count causes error [OK]

Hint: Don't shift more than available arguments to avoid errors [OK]

Common Mistakes:

• Assuming shift works with negative numbers
• Ignoring argument count before shifting
• Expecting shift to print unchanged arguments

5. You want to process all command-line arguments one by one in a bash script using shift. Which script snippet correctly does this?

hard

A. for arg in "$@"; do shift; echo "$arg"; done

B. while [ "$#" -gt 0 ]; do echo "$1"; shift; done

C. shift; while [ "$#" -gt 0 ]; do echo "$1"; done

D. while [ "$#" -ge 1 ]; do echo "$2"; shift 2; done

Solution

1. Step 1: Understand argument count and shifting

   Use while [ "$#" -gt 0 ] to loop while arguments remain.

2. Step 2: Print first argument and shift each iteration

   Inside loop, print $1 then shift to move to next argument.

3. Final Answer:

   while [ "$#" -gt 0 ]; do echo "$1"; shift; done -> Option B

4. Quick Check:

   Loop with shift processes all args one by one [OK]

Hint: Use while loop with $# and shift to process args one by one [OK]

Common Mistakes:

• Using for loop with shift inside causing skipped args
• Not updating argument count in loop condition
• Shifting by 2 causing missed arguments