bash read lines into multiple variables

Viren

2 min read

·

08-02-2025

36

0

Share

Reading multiple lines of input into separate variables in Bash can be a common task, especially when processing configuration files or data streams. This article explores various techniques to achieve this efficiently and robustly, covering different scenarios and error handling.

Method 1: Using read Multiple Times

The simplest approach involves using the read command repeatedly. This is suitable when you know the exact number of lines you need to read.

#!/bin/bash

read var1
read var2
read var3

echo "Variable 1: $var1"
echo "Variable 2: $var2"
echo "Variable 3: $var3"

This script reads three lines from standard input and assigns them to var1, var2, and var3 respectively. Each read command waits for a separate line of input. If fewer than three lines are provided, read will return a non-zero exit status for the missing lines. This can be checked for error handling.

Method 2: Using a Loop with read

For an unknown number of lines, a loop is more flexible. This example reads lines until an empty line is encountered:

#!/bin/bash

i=1
while read line; do
  eval "var$i=\"$line\""
  i=$((i+1))
done

echo "Variables:"
for (( j=1; j<i; j++ )); do
  echo "var$j: ${!var$j}"
done

This script uses a while loop and read to read lines until an empty line is detected (signaling the end of input). It dynamically creates variables (var1, var2, etc.) using eval. Caution: Using eval can be risky if the input is untrusted, as it executes arbitrary commands. Always sanitize your input before using eval. The second loop iterates through the dynamically created variables and prints their values using indirect variable expansion ${!var$j}.

Method 3: Using an Array

A more robust and safer approach is to use an array. This avoids the pitfalls of eval and allows for easier processing:

#!/bin/bash

lines=()
while IFS= read -r line; do
  lines+=("$line")
done

echo "Lines read:"
for i in "${!lines[@]}"; do
  echo "Line $((i+1)): ${lines[i]}"
done

# Access individual lines:
echo "First line: ${lines[0]}"
echo "Second line: ${lines[1]}"

This script uses an array lines to store each line read. IFS= read -r line is crucial; IFS= prevents word splitting, and -r prevents backslash escapes from being interpreted. The script then iterates through the array and prints its contents. Accessing individual lines is straightforward using array indexing.

Method 4: Reading from a File

If the input comes from a file, you can use a loop with while and redirection:

#!/bin/bash

lines=()
while IFS= read -r line; do
  lines+=("$line")
done < input.txt

echo "Lines from file:"
for i in "${!lines[@]}"; do
  echo "Line $((i+1)): ${lines[i]}"
done

This example reads lines from input.txt. Remember to replace input.txt with your actual filename.

Choosing the Right Method

• For a fixed number of lines, using multiple read commands is simplest.
• For an unknown number of lines, using an array is the safest and most recommended approach. Avoid eval unless absolutely necessary and you've carefully sanitized your input.

Remember to always handle potential errors, such as the file not existing or encountering unexpected input formats. Adding error checking will make your scripts more robust. The array method offers the best balance of flexibility, safety, and ease of use for most scenarios.