Learn the best practices and tips for writing professional-grade shell scripts, from using a shebang line to error handling and exit codes.
Shell scripting is an essential skill for any developer, system administrator, or DevOps engineer. It is a powerful tool for automating tasks and managing systems. However, writing a shell script is not just about typing some commands in a file and running it. To create robust, reliable, and maintainable scripts, it’s crucial to follow best practices and tips for shell scripting. In this article, we will discuss the best practices and tips for writing shell scripts as a professional.
Best Practices and Tips for Writing Shell Scripts as a Professional
1. Use a shebang line
Always include a shebang line at the beginning of your script, specifying the interpreter to be used. Example of a shebang line at the beginning of a shell script:
#!/bin/bash # This script prints out the current date and time echo "The current date and time is:" date
In this example, the shebang line #!/bin/bash specifies that the script should be run using the Bash shell interpreter. Without this line, the shell would not know which interpreter to use to run the script.
2. Use descriptive variable names
Use descriptive names for your variables to make your code more readable and understandable. Avoid using single letters or abbreviations.Example of using descriptive variable names in a shell script:
#!/bin/bash # This script calculates the area of a rectangle length=5 # Length of the rectangle width=3 # Width of the rectangle # Calculate the area of the rectangle area=$((length * width)) # Print the result echo "The area of the rectangle with length $length and width $width is: $area"
In this example, the variable names length and width are descriptive and clearly indicate what they represent. Using descriptive variable names makes the code more readable and understandable, as it is immediately clear what the purpose of each variable is. Avoiding single letters or abbreviations also helps prevent confusion and errors.
3. Use indentation
Use indentation to make your code more readable and structured. Indentation helps to differentiate between the different parts of your script. Example of using indentation to make a shell script more readable and structured:
#!/bin/bash
# This script reads in a list of files and prints out their sizes
# Define the list of files
files=(
"file1.txt"
"file2.txt"
"file3.txt"
)
# Loop over the files and print out their sizes
for file in "${files[@]}"
do
# Get the size of the file
size=$(wc -c < "$file")
# Print out the file name and size
echo "File: $file"
echo "Size: $size bytes"
done
In this example, the code is indented to differentiate between the different parts of the script. The for loop and the commands inside it are indented, making it clear which lines of code are executed inside the loop. This makes the code more readable and easier to understand.
4. Check for errors
Always check for errors in your script. You can use the set -e command to exit immediately if any command in your script fails. Example of checking for errors in a shell script using the set -e command:
#!/bin/bash # This script checks if a file exists and prints out its contents filename="example.txt" # Check if the file exists if [ ! -e "$filename" ]; then echo "Error: File '$filename' does not exist" exit 1 fi # Print out the contents of the file set -e cat "$filename"
In this example, the set -e command is used to exit the script immediately if the cat command fails (e.g., if the file is empty or cannot be read). The if statement checks if the file exists and exits the script with an error message if it does not. This helps prevent errors and ensures that the script behaves as expected even if unexpected conditions arise.
5. Comment your code
Add comments to your code to explain what the different parts of your script do. This will help you and others understand your code. Example of adding comments to a shell script to explain what the different parts of the script do:
#!/bin/bash # This script converts a CSV file to a TSV file # Define the input and output file names input_file="data.csv" output_file="data.tsv" # Convert the CSV file to a TSV file # First, replace commas with tabs using the 'tr' command # Then, save the result to the output file cat "$input_file" | tr ',' '\t' > "$output_file" # Print out a success message echo "Conversion complete. Output file: $output_file"
In this example, comments are added to the script to explain what the different parts of the script do. Each comment is preceded by a # symbol, which indicates that the line is a comment and should be ignored by the shell. The comments make it easier for others (and yourself) to understand the purpose of the script and how it works.
6. Use functions
Break your code into functions to make it more modular and reusable. Functions allow you to reuse code and make your code easier to read and understand. Example of using functions to make a shell script more modular and reusable:
#!/bin/bash
# This script performs some data analysis on a file
# Define a function to calculate the sum of a column in a file
# Usage: sum_column FILENAME COLUMN_NUMBER
function sum_column {
local file="$1"
local column="$2"
awk -F ',' '{ sum += $'"$column"' } END { print sum }' "$file"
}
# Define the input file and column numbers
input_file="data.csv"
column1=2
column2=3
# Calculate the sum of the two columns
sum1=$(sum_column "$input_file" "$column1")
sum2=$(sum_column "$input_file" "$column2")
# Print out the results
echo "Sum of column $column1: $sum1"
echo "Sum of column $column2: $sum2"
In this example, two functions sum_column are defined to calculate the sum of a column in a CSV file. The awk command is used inside the function to perform the calculation. The input file and column numbers are defined outside the functions and passed as arguments to the functions. This makes it easy to reuse the functions with different files and column numbers. Using functions makes the code more modular and easier to read and understand.
7. Use quotes
Always use quotes around your variables to avoid issues with spaces and special characters. Example of using quotes around variables to avoid issues with spaces and special characters:
#!/bin/bash
# This script reads in a list of files and prints out their names
# Define the list of files
files=(
"file1.txt"
"file 2.txt"
"file;3.txt"
)
# Loop over the files and print out their names
for file in "${files[@]}"
do
# Print out the file name, using quotes to handle spaces and special characters
echo "File: \"$file\""
done
In this example, quotes are used around the file variable when printing out its name. This is done to avoid issues with spaces and special characters in the file names. If quotes were not used, the echo command would treat spaces and special characters as delimiters, which would cause issues with the output. By using quotes, the echo command treats the entire variable as a single string, which avoids these issues.
8. Use command-line arguments
Use command-line arguments to make your script more flexible and allow it to be used in different ways. Example of using command-line arguments to make a shell script more flexible:
#!/bin/bash # This script reads in a file and prints out a specific column # Check that the correct number of arguments were provided if [[ $# -ne 2 ]]; then echo "Usage: $0 FILENAME COLUMN_NUMBER" exit 1 fi # Get the input file and column number from the command-line arguments input_file="$1" column="$2" # Print out the specified column cut -d ',' -f "$column" "$input_file"
In this example, command-line arguments are used to specify the input file and the column number to be printed. The if statement checks that the correct number of arguments were provided, and exits with an error message if not. The input_file and column variables are then set to the first and second arguments, respectively. The cut command is used to extract the specified column from the input file. By using command-line arguments, the script can be used with different input files and column numbers, making it more flexible and reusable.
9. Use error handling
Use error handling to catch errors and handle them appropriately. You can use the trap command to catch errors and perform a specific action. Example of using error handling with the trap command to catch errors and handle them appropriately:
#!/bin/bash
# This script performs some important operation
# Define a function to handle errors
function handle_error {
echo "An error occurred. Exiting..."
exit 1
}
# Set the trap command to call the handle_error function on any error
trap handle_error ERR
# Perform the important operation
echo "Performing some important operation..."
some_command_that_might_fail
# If the important operation was successful, print a success message
echo "Operation completed successfully."
In this example, the trap command is used to set the handle_error function to be called on any error. The some_command_that_might_fail command is then run, which may or may not fail. If it fails, the handle_error function is called, which prints an error message and exits the script with an error status. If it succeeds, a success message is printed. By using error handling, the script can handle unexpected errors and exit gracefully.
10. Use exit codes
Use exit codes to indicate the success or failure of your script. Use exit 0 for success and a non-zero exit code for failure. Example of using exit codes to indicate the success or failure of a script:
#!/bin/bash # This script performs some important operation # Perform the important operation echo "Performing some important operation..." some_command_that_might_fail # Check the exit status of the command if [[ $? -eq 0 ]]; then # If the command succeeded, print a success message and exit with code 0 echo "Operation completed successfully." exit 0 else # If the command failed, print an error message and exit with a non-zero code echo "An error occurred. Exiting..." exit 1 fi
In this example, the some_command_that_might_fail command is run, and its exit status is checked using the $? variable. If the exit status is 0 (indicating success), a success message is printed and the script exits with a status of 0 (indicating success). If the exit status is non-zero (indicating failure), an error message is printed and the script exits with a non-zero status (indicating failure). By using exit codes, the script can indicate whether it completed successfully or not, which can be useful when calling the script from other scripts or tools.
Conclusion
Writing shell scripts is an important skill for anyone working with Unix-based systems. By following the best practices and tips discussed in this article, you can create shell scripts that are reliable, maintainable, and easy to understand. Whether you’re a beginner or an experienced shell scripter, by incorporating these best practices and tips into your scripting practices, you can become a more professional and effective shell script developer.