Constants

PHP Constants in OOP are unchangeable values that act as reliable anchors in your code—like a “solid ground” amid shifting, dynamic code.

So, if you’re wondering why and how to use constants in PHP OOP, let’s break it all down together.

Why Use PHP Constants in OOP?

PHP constants give you values that won’t accidentally change halfway through your program. For instance, if you define user roles like ADMIN, USER, or GUEST. Using constants for these roles means you won’t mistakenly redefine them elsewhere in your application.

Constants ensure your values stay fixed and reduce potential bugs.

To create a constant in a PHP class, you use the const keyword. This is as easy as defining a variable but with one key difference: the value never changes. Once you’ve set it, it’s locked in place. Here is an example:

class UserRole {
    const ADMIN = 'admin';
    const USER = 'user';
    const GUEST = 'guest';
}

When you do that, you are saying, “These values are fixed.” Whether your codebase has 100 lines or 100,000, you’ll know these constants will always mean exactly what you have set them to mean.

Let's take a look at the following part to understand how to access PHP constants in Classes.

How to Access Constants in PHP Classes

Constants in PHP are inherently public, which means they are accessible outside the class as well. To retrieve a constant, you use the :: operator with the class name, like this:

echo UserRole::ADMIN;  // Outputs: admin

In OOP—you can reach them directly without needing to create an object instance. So, if you need a fixed value multiple times across your application, constants make sure you only define it once and access it reliably.

Constants work a bit differently from properties and methods when it comes to inheritance. They aren’t inherited by child classes the way methods are. If a subclass needs the same constant as the parent class, you will have to define it again. Here’s an example to show how it works:

class BaseClass {
    const TYPE = 'Base';
}

class ChildClass extends BaseClass {
    const TYPE = 'Child';
}

echo ChildClass::TYPE;  // Outputs: Child
echo BaseClass::TYPE;    // Outputs: Base

This gives each class the freedom to define its own constants without the risk of accidentally altering a value in another class.

Anyway, in the following section, you will see the differences between constants and variables in PHP.

Constants vs. Variables

Constants are great for values that should never change, like system settings, user roles, or error codes. Variables, on the other hand, are perfect for data that will vary over time or across different instances of a class. Here’s a quick comparison to keep things clear:

Constants help you lock down values that are fundamental to the structure of your code, while variables keep things flexible where needed.

Let's take a look at the next part to see examples.

Examples of Using PHP Constants in OOP

For instance, we can use it in user roles like ADMIN, EDITOR, and VIEWER keeps permissions consistent.

class UserRole {
    const ADMIN = 'admin';
    const EDITOR = 'editor';
    const VIEWER = 'viewer';
}

Or in Error Codes, If your application has specific error messages, constants make them easy to reuse.

class ErrorCodes {
    const NOT_FOUND = 404;
    const UNAUTHORIZED = 401;
}

Configuration Settings: Let’s say you have a maximum upload size that should stay constant across your app. Defining it as a constant ensures it’s consistent.

class Config {
    const MAX_UPLOAD_SIZE = 5000;  // in kilobytes
}

Let's summarize it.

Wrapping Up

PHP constants are fixed values defined within your class using the const keyword, accessible without instantiating the class. They’re perfect for defining roles, configuration settings, and any value you want to keep consistent across your program.

Constants improve code readability, reduce errors, and provide clear fixed points that don’t change over time.

Thank you for reading. Happy Coding!