YouTipPhp Constant Arrays
## Introduction
In PHP, constants are identifiers for simple values that cannot change during the execution of a script. Historically, PHP constants could only hold scalar values (such as integers, floats, strings, and booleans).
Starting with **PHP 5.6**, it became possible to define constant arrays using the `const` keyword. With the release of **PHP 7.0**, this capability was expanded to the `define()` function, allowing for dynamic runtime definition of constant arrays.
This comprehensive guide covers the syntax, usage, practical examples, and key considerations when working with constant arrays in PHP.
---
## Syntax and Usage
There are two primary ways to define constant arrays in PHP: using the `const` keyword or using the `define()` function.
### 1. Using the `const` Keyword
The `const` keyword defines constants at compile-time. It is clean, readable, and can be used both in the global scope and inside class definitions.
```php
// Global scope
const APP_ROLES = ['admin', 'editor', 'author'];
// Inside a class
class User {
public const PERMISSIONS = [
'create' => true,
'read' => true,
'update' => false,
'delete' => false
];
}
```
### 2. Using the `define()` Function
The `define()` function defines constants at runtime. This allows you to construct arrays dynamically (for example, using function calls or configuration files) before assigning them to a constant.
```php
// Available since PHP 7.0
define('DATABASE_CONFIG', [
'host' => '127.0.0.1',
'username' => 'root',
'password' => 'secret',
'db_name' => 'production_db'
]);
```
---
## Code Examples
### Example 1: Defining and Accessing a Simple Constant Array
You can access elements of a constant array using standard array offset syntax (`[]`).
```php
[
'users' => '/api/v1/users',
'posts' => '/api/v1/posts'
],
'v2' => [
'users' => '/api/v2/users',
'posts' => '/api/v2/posts'
]
]);
// Accessing nested values
echo "V2 Users Endpoint: " . API_ENDPOINTS['v2']['users'] . PHP_EOL;
```
### Example 3: Class Constant Arrays
Class constant arrays are highly useful for defining immutable lookup tables, status codes, or configuration options specific to a class.
```php
'pending',
'PROCESSING'=> 'processing',
'SHIPPED' => 'shipped',
'DELIVERED' => 'delivered'
];
public function isValidStatus(string $status): bool {
return in_array($status, self::STATES, true);
}
}
// Accessing class constant array from outside the class
print_r(OrderStatus::STATES);
$order = new OrderStatus();
var_dump($order->isValidStatus('shipped')); // bool(true)
var_dump($order->isValidStatus('refunded')); // bool(false)
```
---
## Key Differences: `const` vs `define()`
While both approaches allow you to create constant arrays, they behave differently under the hood:
| Feature | `const` | `define()` |
| :--- | :--- | :--- |
| **Execution Time** | Compile-time | Runtime |
| **Scope** | Can be used globally and inside classes | Global scope only (cannot be used inside classes) |
| **Dynamic Values** | Cannot accept dynamic expressions (e.g., function calls) | Can accept dynamic expressions and variables |
| **PHP Version** | Supported since PHP 5.6+ | Supported since PHP 7.0+ |
---
## Considerations and Best Practices
### 1. Immutability
Constant arrays are completely immutable. Once defined, you cannot modify, add, or remove elements. Attempting to do so will result in a fatal error.
```php
const MY_ARRAY = [1, 2, 3];
// This will throw a Fatal Error: Cannot use temporary expression in write context
// MY_ARRAY = 10;
```
### 2. Performance
Using `const` is slightly faster than `define()` because `const` is a language construct parsed at compile-time, whereas `define()` is a function call executed at runtime. Use `const` unless you need dynamic initialization.
### 3. Naming Conventions
By convention, constant names should always be written in uppercase letters with underscores separating words (e.g., `ALLOWED_IP_ADDRESSES`).
### 4. Memory Usage
While constant arrays are highly convenient, defining massive arrays as constants can consume significant memory throughout the lifecycle of the request. For exceptionally large datasets, consider using a configuration class or caching mechanism instead.