How to Read User Input in Bash

A script that only ever does one fixed thing is useful, but a script that can respond to what I type while it’s running is far more powerful. That’s what user input handling gives you. In this article, I’ll show you every practical way I read input in Bash — from simple prompts to silent password entry to reading entire files interactively.

The read Command

The read command is the backbone of user input in Bash. It reads a line from standard input and stores it in one or more variables.

Basic Syntax

read variable_name

Example 1: Reading a Single Value

#!/bin/bash

echo "What is your name?"
read name
echo "Hello, $name! Nice to meet you."

Sample run:

What is your name?
Sarah
Hello, Sarah! Nice to meet you.

Example 2: Prompting on the Same Line with -p

Rather than using a separate echo before read, you can combine them:

#!/bin/bash

read -p "Enter your favorite color: " color
echo "You chose $color"

Sample run:

Enter your favorite color: blue
You chose blue

Example 3: Reading Multiple Values at Once

#!/bin/bash

read -p "Enter your first and last name: " first last
echo "First name: $first"
echo "Last name: $last"

Sample run:

Enter your first and last name: John Smith
First name: John
Last name: Smith

Bash splits the input by whitespace and assigns each word to the corresponding variable. If there are more words than variables, the last variable gets everything remaining.

Reading Passwords Silently

When reading sensitive input, you don’t want it echoed to the screen. The -s flag hides the typed characters.

#!/bin/bash

read -sp "Enter your password: " password
echo
echo "Password received (hidden for security)"

Sample run:

Enter your password: 
Password received (hidden for security)

Nothing appears on screen as you type, which is exactly the behavior you want for sensitive data.

Setting a Timeout for Input

Sometimes you want a script to move on if the user doesn’t respond in time. The -t flag lets you set a timeout in seconds.

#!/bin/bash

if read -t 5 -p "Do you want to continue? (yes/no): " answer
then
    echo "You said: $answer"
else
    echo
    echo "No response received within 5 seconds. Exiting."
fi

If the user doesn’t type anything within 5 seconds, read fails and the else branch runs.

Limiting Input Length

The -n flag reads a fixed number of characters and then automatically continues, without waiting for Enter.

#!/bin/bash

read -n 1 -p "Press any key to continue..." key
echo
echo "You pressed: $key"

This is handy for “press any key” prompts in interactive scripts.

Reading Input into an Array

The -a flag splits input into an array, one element per word.

#!/bin/bash

read -p "Enter three numbers separated by spaces: " -a nums
echo "First number: ${nums[0]}"
echo "Second number: ${nums[1]}"
echo "Third number: ${nums[2]}"

Sample run:

Enter three numbers separated by spaces: 10 20 30
First number: 10
Second number: 20
Third number: 30

Reading Input from a File

read isn’t just for keyboard input — it can also read lines from a file when combined with redirection.

#!/bin/bash

while read -r line
do
    echo "Line content: $line"
done < "data.txt"

Each iteration of the loop pulls one line from data.txt into the line variable.

Reading with a Custom Delimiter

By default, read splits input using the IFS (Internal Field Separator), which is whitespace. You can change this for CSV-like data.

#!/bin/bash

IFS=',' read -p "Enter name,age,city: " name age city
echo "Name: $name"
echo "Age: $age"
echo "City: $city"

Sample run:

Enter name,age,city: Alice,30,Chicago
Name: Alice
Age: 30
City: Chicago

Reading Command-Line Arguments

Although not technically the read command, arguments passed when running the script are a form of user input too:

#!/bin/bash

echo "Script name: $0"
echo "First argument: $1"
echo "Second argument: $2"
echo "All arguments: $@"
echo "Number of arguments: $#"

Sample run:

$ ./script.sh apple banana
Script name: ./script.sh
First argument: apple
Second argument: banana
All arguments: apple banana
Number of arguments: 2

How This Works Internally

• read is a Bash builtin, not an external program, which makes it fast since it doesn’t fork a new process.
• When you call read variable, Bash pauses execution and waits on standard input (file descriptor 0) until it sees a newline character (or reaches EOF, or a timeout if -t is set).
• The line read is split according to the current IFS value, and each resulting field is assigned to the variables you listed, in order.
• With -s, Bash temporarily disables terminal echoing (similar to what stty -echo does) so typed characters aren’t shown, then restores the terminal’s original settings once done.
• $1, $2, etc. are positional parameters set automatically by Bash when the script starts, based on the arguments given on the command line.

Real-World Use Cases

• Interactive setup scripts:

read -p "Enter the domain name for your site: " domain
echo "server_name $domain;" >> nginx.conf

• Confirmation prompts before destructive actions:

read -p "This will delete all files in /tmp/cache. Continue? (y/n): " confirm
if [[ $confirm == "y" ]]
then
    rm -rf /tmp/cache/*
    echo "Cache cleared."
else
    echo "Operation cancelled."
fi

• Login scripts with hidden password entry:

read -p "Username: " user
read -sp "Password: " pass
echo

• Processing a CSV file line by line:

while IFS=',' read -r name score
do
    echo "$name scored $score points"
done < scores.csv

Best Practices

• Always quote variables after reading them ("$name") to avoid word-splitting issues later in the script.
• Use read -r whenever reading from a file to prevent backslashes from being interpreted as escape characters.
• Validate user input before using it, especially before passing it to commands like rm or eval.
• Use -p for prompts instead of a separate echo — it keeps your script shorter and the prompt appears right next to where the user types.

Security Considerations

• Never use eval on raw user input; it can lead to command injection vulnerabilities.
• Always use read -s for passwords or API keys so they aren’t visible on screen or accidentally captured in terminal recordings.
• Be cautious storing input directly into filenames or paths — validate that it doesn’t contain ../ sequences or unexpected special characters.
• Avoid logging raw user input if it could contain sensitive data.

Optimization Tips

• Since read is a builtin, it’s much faster than looping with an external tool for reading lines — prefer while read over calling cat and piping to external utilities in tight loops.
• When reading many lines from a large file, avoid spawning subshells unnecessarily inside the loop body; keep operations builtin where possible.
• Use read -a to grab multiple values in one call instead of parsing a single string manually with cut or awk.

Troubleshooting Common Issues

• Input isn’t being captured correctly — check whether IFS has been changed elsewhere in the script and not reset.
• Script hangs waiting for input — likely means read is running without a -t timeout in a non-interactive context (e.g., a cron job with no terminal attached).
• Trailing whitespace or unexpected characters in variables — make sure you’re using read -r and that your input source uses consistent line endings (watch out for Windows-style \r\n line endings in files).

Frequently Asked Questions

Q: How do I read input without waiting for the Enter key? A: Use read -n 1 to read a single character immediately without requiring Enter.

Q: How do I hide password input in Bash? A: Use the -s flag: read -sp "Password: " password.

Q: Can I set a default value if the user just presses Enter? A: Yes — after reading, check if the variable is empty and assign a default: name=${name:-"Guest"}.

Q: What’s the difference between $* and $@? A: Both represent all positional parameters, but "$@" preserves each argument as a separate word (recommended), while "$*" joins them into a single string.

Common Mistakes to Avoid

• Forgetting -r when reading from files, which can silently corrupt lines containing backslashes.
• Not quoting variables after reading them, leading to word-splitting bugs later.
• Assuming read will always succeed — always check the exit status in scripts that might run without a terminal attached.
• Using echo for password prompts (forgetting -s), accidentally exposing sensitive input.

Summary

Reading user input is what turns a static script into an interactive tool. The read builtin, combined with flags like -p, -s, -t, -n, and -a, covers nearly every input scenario you’ll encounter — from simple prompts to hidden password entry to parsing structured data. Combine that with positional parameters ($1, $2, $@) for command-line arguments, and you have everything you need to build genuinely interactive Bash scripts.

References

• GNU Bash Manual — Bash Builtin Commands (read)
• Bash Reference Manual — Shell Parameters