What Are Positional Parameters in Shell Scripting?
Positional Parameters : Bash or shell scripting, positional parameters allow you to access arguments passed to a script or function. They are incredibly useful when you want to handle user inputs dynamically.
Why Learn Positional Parameters?
- 📦 Helps you write flexible scripts
- 🧑💻 Makes your scripts accept inputs
- 🔁 Supports automation and reusability
- 🧩 Essential for system scripting and DevOps
Key Positional Parameters Explained
| Parameter | Meaning |
|---|---|
$1, $2, … | First, second, etc., arguments |
$0 | Name of the script |
$# | Total number of arguments |
$@ | All arguments as separate words |
$* | All arguments as a single word |
"$@" | Preserves spaces and treats arguments individually |
"$*" | Merges all arguments into one string |
Basic Script Example
#!/bin/bash
echo "Script Name: $0"
echo "First Argument: $1"
echo "Second Argument: $2"
echo "Total Arguments: $#"
echo "All Arguments (separately): $@"
echo "All Arguments (together): $*"Run the script like this:
bash myscript.sh apple banana cherry
Output:
Script Name: myscript.sh
First Argument: apple
Second Argument: banana
Total Arguments: 3
All Arguments (separately): apple banana cherry
All Arguments (together): apple banana cherry
Using "${@}" vs "${*}"
Let’s see the difference:
Example Script:
#!/bin/bash
echo "Using \"\$@\":"
for arg in "$@"; do
echo "$arg"
done
echo "Using \"\$*\":"
for arg in "$*"; do
echo "$arg"
done
Run with:
bash myscript.sh "hello world" "foo bar"
Output:
Using "$@":
hello world
foo bar
Using "$*":
hello
world
foo
bar
📌
"$@"keeps the full argument structure."$*"splits everything.
Bonus: Accessing All Arguments with a Loop
#!/bin/bash
echo "You passed $# arguments."
i=1
for arg in "$@"; do
echo "Argument $i: $arg"
((i++))
done
Best Practices
- Always quote your parameters:
"$1","$@" - Use
$#to validate inputs - Use loops with
"$@"for safe iteration
Real-world Use Case: Validate Arguments
#!/bin/bash
if [ "$#" -ne 2 ]; then
echo "Usage: $0 <filename> <username>"
exit 1
fi
echo "Creating file $1 for user $2..."
5 Practical Examples Using Positional Parameters in Shell Scripts
Example 1: Greeting Script with $1 and $2
#!/bin/bash
echo "Hello, $1!"
echo "Welcome to $2."
Run:
bash greet.sh Nish India
Output:
Hello, Nish!
Welcome to India.
Example 2: Check If Arguments Are Passed Using $#
#!/bin/bash
if [ "$#" -lt 2 ]; then
echo "❌ Error: At least 2 arguments required."
echo "Usage: $0 <arg1> <arg2>"
exit 1
fi
echo "You passed $#: $1 and $2"
Run:
bash check.sh firstOutput:
❌ Error: At least 2 arguments required.
Usage: check.sh <arg1> <arg2>Example 3: Loop Through All Arguments Using $@
#!/bin/bash
echo "📦 List of arguments:"
for item in "$@"; do
echo "- $item"
doneRun:
bash list.sh Mango Banana AppleOutput:
📦 List of arguments:
- Mango
- Banana
- AppleExample 4: Sum Two Numbers Using Positional Parameters
#!/bin/bash
num1=$1
num2=$2
sum=$((num1 + num2))
echo "The sum of $num1 and $num2 is: $sum"Run:
bash sum.sh 5 15Output:
The sum of 5 and 15 is: 20Example 5: Handle All Arguments as One String Using $*
#!/bin/bash
echo "🧵 All arguments as one string: $*"Run:
bash all.sh "one two" "three four"Output:
All arguments as one string: one two three fourSummary Table
| Symbol | What It Does | Example |
|---|---|---|
$1 | First argument | echo $1 |
$2 | Second argument | echo $2 |
$# | Argument count | echo $# |
$@ | All arguments (safe loop) | for i in "$@" |
$* | All arguments (single string) | echo $* |
Conclusion
Mastering positional parameters in shell scripting is essential for writing interactive, powerful, and reusable scripts. Always remember:
$1,$2, etc. — access specific inputs$#— count of arguments"$@"— iterate safely- Use
"$*"when combining arguments into a single string
Frequently Asked Questions (FAQ)
Q1: What are positional parameters in shell scripting?
Positional parameters are special variables in shell scripts that store command-line arguments passed to the script. For example, $1 is the first argument, $2 is the second, and so on.
Q2: What does $0 mean in a shell script?
$0 represents the name of the script itself. It’s often used in usage messages or logs to display which script is running.
Q3: What is the difference between $@ and $*?
$@treats each argument as a separate string, ideal for loops.$*treats all arguments as one single string, often used in quotes.
Example:
for arg in "$@"; do echo "$arg"; done # Handles each argument correctly
for arg in "$*"; do echo "$arg"; done # May split arguments incorrectly
Q4: How do I check how many arguments were passed to the script?
Use $# to get the number of arguments.
echo "You passed $# arguments."Q5: Can I access more than 9 arguments like $10, $11, etc.?
Yes, but use braces to avoid ambiguity.
echo "Tenth argument: ${10}"Q6: How can I loop through all arguments in a script?
for arg in "$@"; do
echo "Argument: $arg"
done
This safely loops through all arguments with proper quoting.
Q7: What happens if an argument is missing in $1, $2, etc.?
It returns an empty string. Always validate input count using $# before accessing specific arguments.
Q8: Are positional parameters only available in Bash?
No, they’re available in all POSIX-compliant shells, including sh, Bash, Zsh, and Ksh.
Q9: How can I print all arguments including the script name?
echo "Script: $0"
echo "Arguments: $@"Q10: Can I shift positional parameters inside a script?
Yes! Use shift to move parameters leftward:
shift
echo "Now \$1 is: $1"You can also Visit other tutorials of Embedded Prep
- What is eMMC (Embedded MultiMediaCard) memory ?
- Top 30+ I2C Interview Questions
- Bit Manipulation Interview Questions
- Structure and Union in c
- Little Endian vs. Big Endian: A Complete Guide
- Merge sort algorithm
Special thanks to @embedded-prep for contributing to this article on Embedded Prep