MENU
contact

PHPでの定数定義について

PHP

採用はこちら

PHPでは、プログラム中で変更しない値を扱うために「定数」を定義できます。

定数は、一度定義すると基本的に値を変更できません。

たとえば、アプリ名、固定の設定値、ステータス、権限名、アップロード上限サイズなど、プログラム全体で共通して使う値を管理するのに便利です。

const APP_NAME = 'Sample App';

echo APP_NAME;

変数は $name のように $ を付けますが、定数には $ を付けません。

$name = 'Sample App'; // 変数

echo APP_NAME;        // 定数

PHPで定数を定義する方法は、主に次の4つです。

// 1. constによる定数
const APP_NAME = 'Sample App';

// 2. define()による定数
define('APP_ENV', 'production');

// 3. クラス定数
class UserRole
{
    public const ADMIN = 'admin';
}

// 4. Enum
enum OrderStatus: string
{
    case Pending = 'pending';
    case Paid = 'paid';
}

それぞれ使える場所や目的が異なるため、違いを理解しておくことが大切です。

目次

PHPの定数とは

PHPの定数とは、名前を付けて固定値を保持する仕組みです。

const TAX_RATE = 0.10;
const DEFAULT_LANGUAGE = 'ja';
const MAX_UPLOAD_SIZE = 10485760;

一度定義した定数は、通常の変数のように後から代入して変更することはできません。

const SITE_NAME = 'My Website';

// SITE_NAME = 'Another Website'; // NG

定数は、以下のような「プログラム中で意味を持つ固定値」に向いています。

const DEFAULT_PAGE_SIZE = 20;
const MAX_RETRY_COUNT = 3;
const DATE_FORMAT = 'Y-m-d';

逆に、ユーザーIDや現在時刻など、実行時に変わる値は定数ではなく変数で扱うべきです。

$currentUserId = 123;
$now = date('Y-m-d H:i:s');

const による定数定義

PHPでは、const キーワードを使って定数を定義できます。

const APP_NAME = 'Sample App';
const VERSION = '1.0.0';

echo APP_NAME;
echo VERSION;

const はPHPの言語構文です。

単純な固定値を定義する場合は、基本的に const を使うと読みやすくなります。

const DEFAULT_LIMIT = 20;
const DEFAULT_TIMEZONE = 'Asia/Tokyo';

const が使える場所

トップレベルの定数であれば、ファイルの直下に書きます。

<?php

const APP_NAME = 'Sample App';

echo APP_NAME;

また、クラス、インターフェース、Enumの中でも使えます。

class User
{
    public const ROLE_ADMIN = 'admin';
}

PHP 8.2以降では、トレイト内にも定数を定義できます。

trait HasStatus
{
    public const STATUS_ACTIVE = 'active';
}

ただし、PHP 8.1以前も対象にする場合、トレイト内定数は使えない点に注意が必要です。

const は if や関数の中では使えない

const による定数定義は、トップレベルで宣言する必要があります。

そのため、次のように if の中で定義することはできません。

if ($debug) {
    const DEBUG_MODE = true; // NG：構文エラー
}

関数の中でも使えません。

function setup(): void
{
    const APP_ENV = 'production'; // NG：構文エラー
}

ループや try/catch の中でも同様に使えません。

foreach ($items as $item) {
    const ITEM_TYPE = 'default'; // NG
}

条件付きで定数を定義したい場合は、後述する define() を使います。

define() による定数定義

define() 関数を使って定数を定義することもできます。

define('APP_NAME', 'Sample App');

echo APP_NAME;

define() は関数なので、実行時に定数を定義できます。

そのため、条件付きで定数を定義したい場合に向いています。

if (!defined('APP_ENV')) {
    define('APP_ENV', 'production');
}

短く書くなら、次のような書き方もあります。

defined('APP_ENV') || define('APP_ENV', 'production');

この書き方は、WordPressなどでもよく見かけます。

defined() で定数が定義済みか確認する

定数がすでに定義されているか確認するには、defined() を使います。

if (defined('APP_NAME')) {
    echo APP_NAME;
}

未定義の場合だけ定義したい場合は、次のように書きます。

if (!defined('APP_NAME')) {
    define('APP_NAME', 'Sample App');
}

定数は基本的に再定義できません。

そのため、define() を使う場合は、必要に応じて defined() で確認すると安全です。

define('APP_NAME', 'Sample App');

// define('APP_NAME', 'Another App'); // NG：再定義はできない

const と define() の違い

const と define() はどちらも定数を定義できますが、使い方に違いがあります。

項目constdefine()
種類言語構文関数
定義タイミングコンパイル時に近い実行時
トップレベルでの定義可能可能
関数内での定義不可可能
if 内での定義不可可能
クラス定数の定義可能不可
名前空間との相性良い注意が必要
基本方針通常はこちらを優先条件付き定義などで使う

基本的には、次のように考えると分かりやすいです。

// 単純な固定値なら const
const DEFAULT_LIMIT = 20;

// 条件付き・実行時に定義したいなら define()
if (!defined('DEFAULT_LIMIT')) {
    define('DEFAULT_LIMIT', 20);
}

通常のPHPコードでは、単純な定数なら const を使うのが分かりやすいです。

一方、WordPressの設定ファイルや、条件付きで定数を定義したい場面では define() がよく使われます。

define() で使える値

define() では、文字列、整数、浮動小数点数、真偽値、配列などを定数として定義できます。

define('APP_NAME', 'Sample App');
define('MAX_COUNT', 10);
define('TAX_RATE', 0.10);
define('DEBUG', true);
define('SUPPORTED_LOCALES', ['ja', 'en']);

配列定数はPHP 7以降で使用できます。

define('COLORS', ['red', 'blue', 'green']);

echo COLORS[0]; // red

また、PHP 8.1以降では、define() の値としてオブジェクトも指定できます。

define('CONFIG_OBJECT', new stdClass());

ただし、実務ではオブジェクトを定数にする設計は慎重に考えた方がよいです。

多くの場合、定数には文字列・数値・真偽値・配列を使う方が自然です。

クラス定数

クラスに関連する固定値は、クラス定数として定義できます。

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

呼び出すときは、クラス名::定数名 の形で参照します。

echo UserRole::ADMIN;

クラス定数は、インスタンスを作らなくても使えます。

class ProductStatus
{
    public const PUBLIC = 'public';
    public const DRAFT = 'draft';
}

echo ProductStatus::PUBLIC;

定数が特定のクラスや概念に関係している場合は、グローバル定数にするよりもクラス定数にした方が整理しやすくなります。

クラス定数を使うメリット

たとえば、ユーザー権限を文字列で直接書くと、タイプミスに気づきにくくなります。

if ($role === 'admin') {
    // 管理者向け処理
}

このような文字列を複数箇所に直接書くと、次のようなミスが起こる可能性があります。

if ($role === 'admn') {
    // タイプミスしている
}

そこで、クラス定数を使います。

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

if ($role === UserRole::ADMIN) {
    // 管理者向け処理
}

このように書くと、値の意味が明確になり、保守しやすくなります。

クラス定数のアクセス修飾子

クラス定数には、public、protected、private を付けられます。

class PaymentStatus
{
    public const PAID = 'paid';
    protected const PENDING = 'pending';
    private const SECRET = 'secret';
}

public const

クラスの外から参照できます。

class PostStatus
{
    public const PUBLISHED = 'published';
}

echo PostStatus::PUBLISHED;

外部から使ってよい値は public const にします。

protected const

そのクラス自身と、継承先クラスから参照できます。

class BaseController
{
    protected const DEFAULT_LIMIT = 20;
}

class UserController extends BaseController
{
    public function index(): int
    {
        return self::DEFAULT_LIMIT;
    }
}

継承先で使わせたいが、クラス外には公開したくない場合に使います。

private const

そのクラスの中だけで参照できます。

class TokenGenerator
{
    private const LENGTH = 32;

    public function generate(): string
    {
        return bin2hex(random_bytes(self::LENGTH));
    }
}

クラス内部だけで使う値は private const にすると、外部から不要に参照されるのを防げます。

self::、static::、parent:: でクラス定数を参照する

クラス内部から定数を参照するときは、主に self:: を使います。

class User
{
    public const ROLE_ADMIN = 'admin';

    public function isAdmin(string $role): bool
    {
        return $role === self::ROLE_ADMIN;
    }
}

self::

self:: は、現在のクラスを指します。

self::ROLE_ADMIN;

基本的には、クラス内部から自分自身の定数を参照するときに使います。

parent::

parent:: は、親クラスの定数を参照するときに使います。

class BaseModel
{
    public const TABLE = 'base';
}

class User extends BaseModel
{
    public function getBaseTable(): string
    {
        return parent::TABLE;
    }
}

static::

static:: は、遅延静的束縛を使って定数を参照します。

class BaseModel
{
    public const TABLE = 'base';

    public function getTable(): string
    {
        return static::TABLE;
    }
}

class User extends BaseModel
{
    public const TABLE = 'users';
}

$user = new User();

echo $user->getTable(); // users

self::TABLE の場合は、定義されているクラス側の定数を参照します。

一方、static::TABLE の場合は、実際に呼び出されたクラス側の定数を参照します。

継承先で定数を上書きする設計にしたい場合は、static:: を使う場面があります。

クラス定数の上書きと final

子クラスでは、親クラスの定数を再定義できます。

class BaseModel
{
    public const TABLE = 'base';
}

class User extends BaseModel
{
    public const TABLE = 'users';
}

echo User::TABLE; // users

ただし、PHP 8.1以降では、クラス定数に final を付けられます。

final を付けたクラス定数は、子クラスで再定義できません。

class BaseModel
{
    final public const TABLE = 'base';
}

class User extends BaseModel
{
    // public const TABLE = 'users'; // NG
}

「この定数は子クラスで変更されたくない」という場合は、final を付けると安全です。

class AppConfig
{
    final public const APP_NAME = 'Sample App';
}

PHP 8.3以降の型付きクラス定数

PHP 8.3以降では、クラス定数に型を付けられます。

class AppConfig
{
    public const string APP_NAME = 'Sample App';
    public const int DEFAULT_LIMIT = 20;
    public const bool DEBUG = false;
    public const array SUPPORTED_LOCALES = ['ja', 'en'];
}

型を付けることで、その定数がどの型の値を持つのか明確になります。

class Pagination
{
    public const int DEFAULT_PER_PAGE = 20;
    public const int MAX_PER_PAGE = 100;
}

PHP 8.3以上の環境であれば、重要なクラス定数には型を付けると、コードの意図が伝わりやすくなります。

ただし、PHP 8.2以前では型付きクラス定数は使えません。

class Pagination
{
    public const int DEFAULT_PER_PAGE = 20; // PHP 8.3未満ではNG
}

PHP 8.2以前も対象にする場合は、次のように型なしで書きます。

class Pagination
{
    public const DEFAULT_PER_PAGE = 20;
    public const MAX_PER_PAGE = 100;
}

名前空間と定数

PHPでは、名前空間内で定数を定義できます。

namespace App\Config;

const APP_NAME = 'Sample App';

この定数は、完全修飾名で参照できます。

echo \App\Config\APP_NAME;

同じ名前空間内であれば、そのまま参照できます。

namespace App\Config;

const APP_NAME = 'Sample App';

echo APP_NAME;

別の名前空間から使う場合は、use const でインポートできます。

namespace App;

use const App\Config\APP_NAME;

echo APP_NAME;

クラス定数の場合は、通常のクラスと同じように use します。

namespace App\Enums;

class UserRole
{
    public const ADMIN = 'admin';
}

namespace App\Controllers;

use App\Enums\UserRole;

echo UserRole::ADMIN;

名前空間内で define() を使う場合の注意点

名前空間内で define() を使う場合は注意が必要です。

たとえば、次のように書いた場合、

namespace App\Config;

define('APP_NAME', 'Sample App');

これは \App\Config\APP_NAME ではなく、指定した名前どおりに APP_NAME という定数を定義します。

名前空間付きの定数として定義したい場合は、名前空間を含めて指定します。

namespace App\Config;

define(__NAMESPACE__ . '\APP_NAME', 'Sample App');

echo APP_NAME;
echo \App\Config\APP_NAME;

名前空間内の定数を定義したい場合は、基本的には define() よりも const の方が分かりやすいです。

namespace App\Config;

const APP_NAME = 'Sample App';

定数名の命名規則

PHPでは、定数名は大文字のスネークケースで書くことが多いです。

const APP_NAME = 'Sample App';
const DEFAULT_PAGE_SIZE = 20;
const MAX_UPLOAD_SIZE = 10485760;

クラス定数も同じように、大文字のスネークケースで書かれることが多いです。

class OrderStatus
{
    public const PENDING = 'pending';
    public const PAID = 'paid';
    public const CANCELED = 'canceled';
}

ただし、プロジェクトのコーディング規約によってはルールが異なる場合があります。

基本的には、チームやフレームワークの規約に合わせるのがよいです。

マジック定数

PHPには、あらかじめ用意されている特殊な定数があります。

これらは「マジック定数」と呼ばれます。

代表的なものは次の通りです。

__FILE__
__DIR__
__LINE__
__FUNCTION__
__CLASS__
__METHOD__
__NAMESPACE__

__FILE__

現在のファイルのフルパスを返します。

echo __FILE__;

__DIR__

現在のファイルがあるディレクトリを返します。

echo __DIR__;

ファイル読み込みでよく使われます。

require_once __DIR__ . '/vendor/autoload.php';

__LINE__

現在の行番号を返します。

echo __LINE__;

__CLASS__

現在のクラス名を返します。

class User
{
    public function showClass(): void
    {
        echo __CLASS__;
    }
}

__METHOD__

現在のメソッド名を返します。

class User
{
    public function showMethod(): void
    {
        echo __METHOD__;
    }
}

マジック定数は、ログ出力やデバッグで使われることがあります。

未定義定数に注意する

PHPでは、未定義の定数をそのまま書くとエラーになります。

echo admin; // NG

これは文字列 'admin' ではありません。

正しくは、文字列としてクォートします。

echo 'admin';

または、定数として定義してから使います。

class UserRole
{
    public const ADMIN = 'admin';
}

echo UserRole::ADMIN;

なお、古いPHPでは未定義定数が文字列として解釈される挙動がありました。

しかし、PHP 8.0以降ではエラーになります。

現在のPHPを前提にするなら、未定義定数を文字列のように使う書き方は避けるべきです。

定数の値に使えるもの

定数には、主に次のような値を使います。

const SITE_NAME = 'Sample Site';       // string
const MAX_COUNT = 10;                  // int
const TAX_RATE = 0.10;                 // float
const DEBUG = false;                   // bool
const LANGUAGES = ['ja', 'en'];        // array

クラス定数でも同様です。

class Config
{
    public const APP_NAME = 'Sample App';
    public const VERSION = '1.0.0';
    public const SUPPORTED_LANGUAGES = ['ja', 'en'];
}

定数には固定値を入れるのが基本です。

実行時に変化する値や、環境によって頻繁に変わる値は、定数よりも設定ファイルや環境変数で管理する方が向いています。

定数式

定数の値には、他の定数を使った式を指定できます。

const BASE_PRICE = 1000;
const TAX_RATE = 0.10;
const PRICE_WITH_TAX = BASE_PRICE * (1 + TAX_RATE);

echo PRICE_WITH_TAX;

クラス定数でも、定数式を使えます。

class Price
{
    public const BASE = 1000;
    public const TAX_RATE = 0.10;
    public const WITH_TAX = self::BASE * (1 + self::TAX_RATE);
}

echo Price::WITH_TAX;

このように、固定値同士の計算結果を定数として定義できます。

設定値と定数の違い

定数は、プログラムの中で変わらない値に向いています。

const MAX_RETRY_COUNT = 3;
const DEFAULT_PAGE_SIZE = 20;

一方、環境によって変わる値は、定数ではなく設定ファイルや環境変数で管理する方が適しています。

たとえば、次のような値です。

const DB_HOST = 'localhost';
const DB_USER = 'root';
const DB_PASSWORD = 'password';

学習用の小さなコードでは問題ない場合もありますが、実務ではあまりおすすめできません。

本番環境、開発環境、ステージング環境で値が変わるためです。

実務では、環境変数などから取得する方が一般的です。

$dbHost = getenv('DB_HOST');
$dbUser = getenv('DB_USER');
$dbPassword = getenv('DB_PASSWORD');

定数に向いているのは、次のような値です。

class UploadConfig
{
    public const MAX_FILE_SIZE = 10 * 1024 * 1024;
    public const ALLOWED_EXTENSIONS = ['jpg', 'png', 'gif'];
}

「環境によって変わる値」は設定として扱い、「プログラム上の固定ルール」は定数として扱うと分かりやすいです。

constant() 関数で定数を動的に参照する

定数名を文字列として持っている場合、constant() 関数で値を取得できます。

const APP_NAME = 'Sample App';

$name = 'APP_NAME';

echo constant($name); // Sample App

クラス定数も文字列で参照できます。

class UserRole
{
    public const ADMIN = 'admin';
}

echo constant(UserRole::class . '::ADMIN');

ただし、動的な定数参照はコードが読みにくくなることがあります。

必要な場面に限定して使うのがよいです。

::class について

PHPでは、クラス名を文字列として取得するために ::class を使えます。

class User
{
}

echo User::class;

名前空間がある場合は、完全修飾クラス名を取得できます。

namespace App\Models;

class User
{
}

echo User::class; // App\Models\User

Laravelなどのフレームワークでは、コントローラーやモデルの指定でよく使われます。

Route::get('/users', [UserController::class, 'index']);

::class はクラス定数のような構文で使えますが、ユーザーが const で定義する通常の定数とは性質が異なります。

Enumと定数

PHP 8.1以降では、Enumを使えます。

Enumは、決まった値の集合を表現するための仕組みです。

enum OrderStatus
{
    case Pending;
    case Paid;
    case Canceled;
}

文字列や整数の値を持たせたい場合は、Backed Enumを使います。

enum OrderStatus: string
{
    case Pending = 'pending';
    case Paid = 'paid';
    case Canceled = 'canceled';
}

使うときは次のように書きます。

$status = OrderStatus::Paid;

echo $status->value; // paid

Backed Enumで使える値の型は、string または int です。

enum HttpStatus: int
{
    case OK = 200;
    case NotFound = 404;
}

1つのEnum内で、string と int を混在させることはできません。

// NG
enum Status: string
{
    case Active = 'active';
    // case Error = 500; // 型が違うためNG
}

クラス定数とEnumの使い分け

固定値をまとめたいだけなら、クラス定数で十分です。

class OrderStatus
{
    public const PENDING = 'pending';
    public const PAID = 'paid';
    public const CANCELED = 'canceled';
}

if ($status === OrderStatus::PAID) {
    // 支払い済み
}

一方で、「この値のどれかしか許可しない」という型安全性を高めたい場合は、Enumが向いています。

enum OrderStatus: string
{
    case Pending = 'pending';
    case Paid = 'paid';
    case Canceled = 'canceled';
}

function updateStatus(OrderStatus $status): void
{
    // ...
}

updateStatus(OrderStatus::Paid);

クラス定数の場合、関数の引数は単なる文字列になりがちです。

function updateStatus(string $status): void
{
    // ...
}

updateStatus('paid');
updateStatus('wrong_value'); // 文字列なので渡せてしまう

Enumを使うと、定義されたcase以外を渡しにくくなります。

updateStatus(OrderStatus::Paid);

PHP 8.1以上の環境で、ステータス、種別、権限、決済状態などを扱うなら、Enumの利用も検討するとよいです。

実務でよくある定数設計パターン

設定値をまとめる

class AppConfig
{
    public const APP_NAME = 'Sample App';
    public const DEFAULT_LOCALE = 'ja';
    public const TIMEZONE = 'Asia/Tokyo';
}

echo AppConfig::APP_NAME;

ステータスをまとめる

class PostStatus
{
    public const DRAFT = 'draft';
    public const PUBLISHED = 'published';
    public const ARCHIVED = 'archived';
}

if ($post->status === PostStatus::PUBLISHED) {
    // 公開中の記事
}

選択肢一覧をまとめる

class PostStatus
{
    public const DRAFT = 'draft';
    public const PUBLISHED = 'published';
    public const ARCHIVED = 'archived';

    public const ALL = [
        self::DRAFT,
        self::PUBLISHED,
        self::ARCHIVED,
    ];
}

if (in_array($status, PostStatus::ALL, true)) {
    // 有効なステータス
}

ラベルもまとめる

class PostStatus
{
    public const DRAFT = 'draft';
    public const PUBLISHED = 'published';
    public const ARCHIVED = 'archived';

    public const LABELS = [
        self::DRAFT => '下書き',
        self::PUBLISHED => '公開済み',
        self::ARCHIVED => 'アーカイブ',
    ];

    public static function label(string $status): string
    {
        return self::LABELS[$status] ?? '不明';
    }
}

echo PostStatus::label(PostStatus::PUBLISHED); // 公開済み

ただし、PHP 8.1以上であれば、このようなケースはEnumで書く方が自然な場合もあります。

enum PostStatus: string
{
    case Draft = 'draft';
    case Published = 'published';
    case Archived = 'archived';

    public function label(): string
    {
        return match ($this) {
            self::Draft => '下書き',
            self::Published => '公開済み',
            self::Archived => 'アーカイブ',
        };
    }
}

echo PostStatus::Published->label(); // 公開済み

WordPressでよく使われる定数

WordPressでは、設定やセキュリティチェックで定数がよく使われます。

代表的なものには、次のような定数があります。

ABSPATH
WP_DEBUG
WP_HOME
WP_SITEURL
WP_CONTENT_DIR
WP_CONTENT_URL

プラグインやテーマのPHPファイルでは、次のようなコードをよく見かけます。

defined('ABSPATH') || exit;

これは、ABSPATH が定義されていなければ処理を終了する、という意味です。

WordPressを経由せずにPHPファイルへ直接アクセスされた場合の対策として使われます。

また、wp-config.php では次のように define() を使って設定値を定義します。

define('WP_DEBUG', true);

WordPressでは歴史的にも、設定値の定義に define() がよく使われています。

条件付き定義や、読み込みタイミングとの相性がよいためです。

定数定義でよくあるミス

定数に $ を付けてしまう

const $APP_NAME = 'Sample App'; // NG

正しくは、$ を付けません。

const APP_NAME = 'Sample App';

未定義定数を文字列のように使ってしまう

echo admin; // NG

正しくは、文字列としてクォートします。

echo 'admin';

または、定数として定義します。

class UserRole
{
    public const ADMIN = 'admin';
}

echo UserRole::ADMIN;

定数を再定義しようとする

define('APP_NAME', 'Sample App');
define('APP_NAME', 'Another App'); // NG

再定義を避けるには、defined() で確認します。

if (!defined('APP_NAME')) {
    define('APP_NAME', 'Sample App');
}

変わる値を定数にしてしまう

const CURRENT_USER_ID = 123; // あまり適切ではない

ログインユーザーIDのように状況によって変わる値は、変数やオブジェクトで扱うべきです。

$currentUserId = 123;

環境ごとに変わる秘密情報を定数に直書きする

const API_SECRET = 'xxxxxxxx';

APIキーやDBパスワードのような秘密情報は、ソースコードに直接書くべきではありません。

環境変数や安全な設定管理を使う方が適切です。

$apiSecret = getenv('API_SECRET');

実務でのおすすめの使い分け

PHPで定数を定義するときは、次のように使い分けると分かりやすいです。

目的おすすめ
単純な固定値を定義したいconst
条件付きで定義したいdefine()
実行時に定義したいdefine()
クラスに関連する固定値を定義したいクラス定数
外部から参照させたいpublic const
クラス内部だけで使いたいprivate const
子クラスで上書きされたくないfinal public const
PHP 8.3以上で型を明確にしたい型付きクラス定数
ステータスや種別を型安全に扱いたいEnum

基本的な方針としては、次のように考えるとよいです。

// 単純な固定値
const APP_NAME = 'Sample App';

// 条件付き定義
defined('APP_ENV') || define('APP_ENV', 'production');

// クラスに関連する固定値
class UserRole
{
    public const ADMIN = 'admin';
    public const EDITOR = 'editor';
}

// PHP 8.1以降で型安全に扱いたい値
enum OrderStatus: string
{
    case Pending = 'pending';
    case Paid = 'paid';
}

まとめ

PHPでは、定数を使うことで、プログラム中の固定値を分かりやすく管理できます。

通常の固定値であれば、まずは const を使うのが基本です。

const APP_NAME = 'Sample App';

条件付きで定義したい場合や、WordPressの設定のように実行時に定義したい場合は、define() を使います。

defined('APP_ENV') || define('APP_ENV', 'production');

クラスに関連する値は、クラス定数としてまとめると管理しやすくなります。

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

PHP 8.1以降でステータスや種別を扱う場合は、Enumも有力な選択肢です。

enum OrderStatus: string
{
    case Pending = 'pending';
    case Paid = 'paid';
    case Canceled = 'canceled';
}

また、PHP 8.3以降では型付きクラス定数も使えます。

class Pagination
{
    public const int DEFAULT_PER_PAGE = 20;
}

PHPの定数定義では、const、define()、クラス定数、Enumの違いを理解して、用途に応じて使い分けることが大切です。

以上、PHPでの定数定義についてでした。

最後までお読みいただき、ありがとうございました。

PHP
よかったらシェアしてね！
  • URLをコピーしました！
  • URLをコピーしました！

関連記事

  1. ホーム
  2. PHP
  3. PHPでの定数定義について
目次