PHP does not support nested multiline comments, and attempting to nest them can cause unexpected code execution or parse errors; the first / closes the entire comment block, so any code following it—even if intended to be commented—will be executed, leading to bugs or fatal errors when functions are inadvertently redeclared; to avoid this, use // comments, IDE block commenting, or wrap code in if (0) { } instead of / */ when commenting out code containing existing comments.

You can't nest multiline comments in PHP — and trying to do so can lead to subtle, hard-to-catch bugs. While this might seem like a minor language quirk, it's a real pitfall, especially when commenting out large blocks of code during debugging or refactoring.

PHP only recognizes /* */ as multiline comment delimiters, and the first */ closes the entire comment block — regardless of how many /* came before it. This means nesting doesn’t work the way you might expect from other languages or programming constructs.

What Happens When You Try to Nest?

Consider this seemingly harmless code:

/*
    Some important function
    /*
        This is a nested comment
    */
    Still inside what I thought was a comment
*/
echo "Hello, world!";

You might expect the entire block to be commented out — including the echo statement. But here's what actually happens:

• The first /* starts the comment.
• The first */ (after "nested comment") ends the comment.
• Everything after that — including Still inside... and the echo — is executed as PHP code.

So your "commented-out" echo will run, and you’ll get output. Worse, if there’s invalid or incomplete PHP syntax after the premature */, you’ll get a parse error that’s confusing to debug.

Why This Is Dangerous in Practice

The biggest risk isn't theoretical — it's when developers use /* ... */ to temporarily disable chunks of code.

Imagine this scenario during debugging:

/*
function processUserData($data) {
    /* Validate input */
    if (!isValid($data)) {
        logError("Invalid data");
        return false;
    }
    performAction($data);
}
*/

Looks safe, right? But the inner comment (/* Validate input */) contains a */, which terminates the outer comment early. The result?

• function processUserData(...) is no longer commented out.
• If this file is included or run, the function gets defined — possibly causing conflicts or unintended behavior.
• Even worse: if the function already exists, you’ll get a fatal "Cannot redeclare" error.

This kind of mistake is especially dangerous because:

• There’s no warning from PHP.
• Syntax highlighters sometimes fail to catch it, coloring everything as "commented" when it’s not.
• The error may appear far from the actual cause.

Safer Alternatives

Instead of relying on /* */, use these safer approaches:

• Use multiple line comments (//)
  Especially for temporary debugging:

  // function processUserData($data) {
  //     if (!isValid($data)) {
  //         logError("Invalid data");
  //         return false;
  //     }
  //     performAction($data);
  // }

• Use IDE block commenting
  Most editors let you select code and toggle // on each line with a shortcut. It’s fast and safe.

• Use # for shell-style comments
  Same behavior as //, but some prefer it for visual distinction.

• For large blocks, consider wrapping in if (0) { ... }
  Example:

  if (0) {
      function processUserData($data) {
          /* Validate input */
          if (!isValid($data)) {
              logError("Invalid data");
              return false;
          }
          performAction($data);
      }
  }

  This ensures the code is parsed (so syntax errors are still caught) but never executed.

  Bottom Line

  PHP’s multiline comments don’t support nesting — full stop. Relying on them to comment out code with existing /* */ comments inside is asking for trouble. The parser doesn’t care about indentation or intent; it stops at the first */.

  The fix? Avoid /* */ for commenting out code during development. Stick to // or use conditional blocks. It’s a small habit change that prevents big headaches.

  Basically: if you're commenting out code that contains any /* or */, assume it will break. Plan accordingly.

  The above is the detailed content of The Perils of Nested Multiline Comments in PHP. For more information, please follow other related articles on the PHP Chinese website!