include can return a value like a function, which becomes the result of the include expression; 2. echo include outputs the return value of include, often 1 if the file returns true (default on success); 3. any echo inside the included file outputs immediately, separate from its return value; 4. to use returned data, assign include to a variable instead of echoing it directly; 5. avoid mixing output and return in included files unless intentional, as it can cause confusion and unexpected behavior.

In PHP, echo, include, and return values serve distinct but sometimes overlapping roles—especially when used together in dynamic scripts. Understanding how they interact is key to writing predictable and maintainable code.

How include Works with Return Values

The include statement does more than just insert code—it can also return values, much like a function call. When you include a file, the included file can use return to send back a value:

// config.php
return [
    'host' => 'localhost',
    'port' => 3306
];

// main.php
$config = include 'config.php';
echo $config['host']; // Outputs: localhost

This pattern is commonly used for configuration files. The key point: only the return statement in the included file becomes the value of the include expression. Anything echoed or printed before the return is still output.

What Happens When You echo include

You might see code like:

echo include 'somefile.php';

This works, but its behavior depends on what somefile.php contains:

• If the file returns a string or number, that value will be echoed.
• If it returns true (default when no return is used), echo will output 1.
• If it returns null or false, echo outputs nothing or `, respectively (thoughfalsemay show as blank or0` depending on context).

Example:

// somefile.php
echo "Hello from included file! ";
return "Return value";

// main.php
echo include 'somefile.php';
// Output: Hello from included file! 1

Wait—why 1? Because include returns true (indicating success), and echo true becomes 1. The "Return value" is returned but not automatically echoed unless you explicitly use it.

So the output is:

• "Hello from included file! " — from inside the included file
• 1 — from echo include ... (echoing the boolean true result)

The returned string "Return value" is lost unless captured:

$result = include 'somefile.php'; // $result = "Return value"
echo $result; // Now it prints

Common Pitfalls and Best Practices

• Don’t echo include expecting a returned string – unless you're certain the file returns a printable value, you’ll likely just get 1 or blank.

• Use include for side effects (like output or variable definition) or return values—but not both at once, unless intentional.

• Prefer capturing return values when using include as data loader:

  $data = include 'data.php'; // Clean and clear

• Avoid echoing the result of include unless debugging or templating deliberately.

Summary

• include can return values; that return becomes the expression’s value.
• echo include will print whatever the include evaluates to—often 1 if just including a file with no explicit return.
• Output from within the included file (via echo) happens immediately, separate from the return value.
• Mixing output and return in included files can lead to confusion—keep the purpose clear: either generate output, or return data.

Basically: echo outputs things, include pulls in code (and can return values), and combining them carelessly can lead to unexpected results. Know what the included file does, and handle its return value appropriately.

The above is the detailed content of The Interplay of `echo`, `include`, and Return Values in PHP. For more information, please follow other related articles on the PHP Chinese website!