Why You Should Use function_exists in Your PHP Helpers

In Laravel projects or any large scale PHP application it's common to create helper files that contain reusable functions. These helpers make your code cleaner and more efficient.

But there's a common issue, defining the same function more than once will cause a Fatal error..

What's the problem?

If the same function is declared twice, PHP will throw an error like this:

Fatal error: Cannot redeclare function_name()

This often happens because of:

• Repeated includes:
  You might accidentally load the same helper file more than once (manually or via different service providers).

• Package conflicts:
  A package you install might define a helper function with the same name as yours.

The safe solution

To prevent this issue, wrap your helper functions like this:

if (!function_exists('sayHello')) {
    function sayHello() {
        return 'Hello!';
    }
}

This way, if the function already exists, PHP will skip redefining it, and your app will keep running smoothly.

In Laravel projects

Even with Laravel’s powerful autoloading and service container, this pattern is essential. It keeps your project safe from unexpected conflicts and ensures maximum compatibility especially when working with custom helpers or external packages.

Summary:
Always wrap your helper functions with function_exists
It’s a small thing that can save you from big problems.

Comments

[david duymelinck]

In Laravel projects or any large scale PHP application it's common to create helper files that contain reusable functions.

Function files are not object oriented, this is the reason why they need to be added to the composer.json file.
The object oriented way is to make a class with static methods, and example is the Str class.

Basically using function_exists is because the developers are too lazy to namespace the functions. The only thing that needs to happen when a function is namespaces, is that in the file where the function is used a use statement needs to be added.

namespace App\Http\Controllers;
// the function file has the Laravel\Helper\App namespace.
use function Laravel\Helper\App\sayHello;

class TestController
{
     public function index()
     {
            echo sayHello();
     }
}

By adding a namespace the function has more context.

Don't always follow the framework code blindly, it can save you two extra lines for each function you add.

[Yasser Elgammal]

Thank you for your comment.

Laravel (like many other frameworks) intentionally allows globally scoped helper functions to provide quick and convenient access to commonly used utilities.

It's often a trade-off between simplicity and structure, depending on the specific needs of the project.

As you know, Laravel already includes internal helper functions like trans() for localization.

Thanks again for sharing your perspective!

[david duymelinck]

If other frameworks are using globally scoped functions it is very sparingly.

I haven't used function_exist as a global check since PHP has introduced namespaces.
Why would you not structure the functions, but structure all the classes? Functions are more in need of context because they are loose elements.

I shouldn't have mentioned it is lazy not to namespace functions, there are good reasons why a function should be global.
On the other hand package and application functions seems to me like prime candidates for namespacing.