The key methods for debugging shell scripts include: 1. Use set -x or bash -x to view execution details. You can add set -x or runtime parameters to the beginning of the script to display each execution command and its parameters to help locate problems; 2. Check whether the variable is empty or assigned errors, print the variables through echo, use ${VAR_NAME:?} to force check whether the variable exists, and pay attention to the correct use of quotes to avoid parsing errors; 3. Add error handling logic to improve robustness, such as using set -e to exit immediately, combine the trap command to clean or record, and handle exceptions on important commands; 4. Use the shellcheck tool to discover potential problems in advance, and run shellcheck script.sh after installation to recognize syntax errors, spelling problems and bad practices. Mastering these techniques can significantly improve the efficiency and code quality of Shell script debugging.

Debugging shell scripts is actually not mysterious. As long as you master a few key methods, you can quickly locate problems. When a shell script errors, detailed error information is usually not given, so some skills are needed to "see" the execution process of the script.

1. Use set -x or bash -x to view execution details

This is the most direct way to debug. At the beginning of the script:

 set -x

Or add the -x parameter when running the script:

 bash -x script.sh

This allows Bash to output the actual commands and parameters of each line, so that you can see the result after variable replacement and which line has a problem.

Tip: If you only want to see the execution of a certain piece of code, you can add set -x and set x before and after that part to temporarily enable debugging.

2. Check whether the variable is empty or the assignment error is

Many shell scripts have problems with variables. For example, variables are not assigned, quotation marks are used improperly, path splicing is incorrect, etc.

You can troubleshoot by:

• Print the variable before it is used:

   echo "Variable value is: $VAR_NAME"

• Use ${VAR_NAME:?} to force check whether the variable exists. If it is empty or undefined, an error will be reported.

• Pay attention to the use of quotes to avoid spaces causing command parsing errors:

   # Error example (when $FILE_NAME contains spaces)
  cp $FILE_NAME /backup/
  
  # Correct writing method cp "$FILE_NAME" /backup/

3. Add error handling logic to improve robustness

By default, the shell script will continue to execute when encountering an error, which may cause further errors in subsequent steps. You can make the script more "smart" in the following ways:

• At the beginning of the script:

   set -e

  In this way, once a command returns a non-0 status code, the script will exit immediately to prevent errors from spreading.

• Cooperate with trap command to clean up or log records:

   trap 'echo "The script errors in line $LINENO"; exit' ERR

• Add judgments on important commands:

   if ! grep "pattern" file.txt; then
    echo "Specified content not found"
    exit 1
  fi

4. Use shellcheck tool to discover potential problems in advance

Shell does not check for syntax errors before running, like compiled languages. At this time, you can use the static check tool shellcheck :

Use after installation:

 shellcheck script.sh

It can help you spot grammatical errors, recommend best practices, and point out possible pitfalls, such as:

• No quotes are added when using [ ]
• Used a deprecated combination of commands
• Variable name misspelling

Basically that's it. Although shell scripts are simple, they are easy to cause headaches when debugging because of the lack of strong type and strict error prompt mechanisms. However, as long as you make good use of the above methods, most problems can be located and solved quickly.

The above is the detailed content of How to debug a shell script?. For more information, please follow other related articles on the PHP Chinese website!