PHPの変数のスコープとは、変数を参照できる範囲のことです。
簡単にいうと、ある変数を「どこで使えるのか」を決めるルールです。
PHPでは、変数を定義した場所によって、その変数を使える範囲が変わります。
特に重要なのは、関数の外で定義した変数は、関数の中からそのまま使えないという点です。
たとえば、次のコードを見てください。
$name = "佐藤";
function showName() {
echo $name;
}
showName();
一見すると "佐藤" と表示されそうですが、このコードでは関数内の $name は未定義です。
PHPでは、関数の外側と内側で変数のスコープが分かれているため、外側で定義した $name を関数内で自動的に参照することはできません。
PHPの変数スコープを理解しておくと、未定義変数の警告や、意図しない値の上書き、global への依存などを防ぎやすくなります。
PHPの主な変数スコープ
PHPでまず押さえておきたいスコープは、主に次のとおりです。
| 種類 | 内容 |
|---|---|
| グローバルスコープ | 関数やメソッドの外側で定義された変数の範囲 |
| ローカルスコープ | 関数やメソッドの内側で定義された変数の範囲 |
| スーパーグローバル | $_GET や $_POST など、どこからでも参照できる特別な変数 |
| クロージャのスコープ | 無名関数内のスコープ |
| クラスの可視性 | public、protected、private によるアクセス制御 |
PHPでは、JavaScriptのように if や for の {} が必ず新しいスコープを作るわけではありません。
そのため、PHPの変数スコープを理解する際は、まず次の違いを押さえることが大切です。
// 関数外：グローバルスコープ
$message = "こんにちは";
function hello() {
// 関数内：ローカルスコープ
$text = "Hello";
}
グローバルスコープとは？
グローバルスコープとは、関数やメソッドの外側で定義された変数の有効範囲のことです。
$message = "こんにちは";
echo $message;
この $message はグローバルスコープの変数です。
同じグローバルスコープ内であれば、後続の処理から参照できます。
$siteName = "My Blog";
echo $siteName;
この場合、$siteName は問題なく表示されます。
グローバル変数は関数内から自動的には参照できない
注意したいのは、グローバルスコープで定義した変数が、関数内から自動的に参照できるわけではないことです。
$price = 1000;
function showPrice() {
echo $price;
}
showPrice();
このコードでは、関数 showPrice() の中にある $price は未定義です。
関数の外に $price があっても、関数内のローカルスコープには自動的に持ち込まれません。
ローカルスコープとは？
ローカルスコープとは、関数やメソッドの内側で定義された変数の有効範囲のことです。
function hello() {
$message = "こんにちは";
echo $message;
}
hello();
この $message は、関数 hello() の中でだけ使える変数です。
関数の外からは参照できません。
function hello() {
$message = "こんにちは";
}
hello();
echo $message;
このコードでは、関数外の $message は定義されていません。
そのため、PHPのバージョンやエラー表示設定によって、未定義変数に関する Warning や Notice が発生する可能性があります。
関数内の変数は外側に出てこない
関数の中で作った変数は、基本的にその関数の外では使えません。
function createMessage() {
$message = "こんにちは";
}
createMessage();
echo $message; // 関数外では未定義
関数内で作った値を外で使いたい場合は、return を使って値を返します。
function createMessage() {
$message = "こんにちは";
return $message;
}
$result = createMessage();
echo $result;
関数外の変数を関数内で使う方法
関数の外側にある変数を関数内で使いたい場合、主な方法は次の3つです。
- 引数で渡す
globalを使う$GLOBALSを使う
実務では、基本的に引数で渡す方法が最もおすすめです。
引数で渡す
もっともわかりやすく、安全なのは、必要な値を関数の引数として渡す方法です。
$price = 1000;
function showPrice($price) {
echo $price;
}
showPrice($price);
このように書けば、関数の中で $price を使えます。
この書き方の良いところは、関数がどの値を必要としているのかが明確になることです。
function calculateTax($price, $taxRate) {
return $price * $taxRate;
}
echo calculateTax(1000, 0.1);
この関数は、$price と $taxRate を使って税額を計算していることが、引数を見るだけでわかります。
実務では、必要な値は引数で受け取り、結果は戻り値で返す書き方が基本です。
function calculateTotal($price, $taxRate) {
$tax = $price * $taxRate;
return $price + $tax;
}
$total = calculateTotal(1000, 0.1);
echo $total;
globalキーワードを使う
関数内でグローバル変数を使う方法として、global キーワードがあります。
$price = 1000;
function showPrice() {
global $price;
echo $price;
}
showPrice();
global $price; と書くことで、関数内の $price がグローバルスコープの $price を参照するようになります。
ただし、global の多用はおすすめできません。
理由は、関数が外部の変数に依存していることがわかりにくくなるためです。
$taxRate = 0.1;
function calculateTax($price) {
global $taxRate;
return $price * $taxRate;
}
この関数は、引数だけを見ると $price だけを使っているように見えます。
しかし実際には、外側の $taxRate に依存しています。
このようなコードは、規模が大きくなるほど読みづらく、テストもしにくくなります。
より良い書き方は、次のように引数で渡す方法です。
function calculateTax($price, $taxRate) {
return $price * $taxRate;
}
echo calculateTax(1000, 0.1);
global はPHPの機能として使えますが、実務では必要な場面に限定するのがよいでしょう。
$GLOBALSを使う
PHPには $GLOBALS というスーパーグローバル変数があります。
$GLOBALS は、グローバルスコープの変数を配列として参照できる仕組みです。
$price = 1000;
function showPrice() {
echo $GLOBALS['price'];
}
showPrice();
このコードでは、$GLOBALS['price'] によってグローバル変数 $price を参照しています。
値を書き換えることもできます。
$count = 1;
function increment() {
$GLOBALS['count']++;
}
increment();
echo $count; // 2
ただし、$GLOBALS も global と同じく、使いすぎるとコードの依存関係が見えにくくなります。
そのため、実務では多用せず、基本的には引数と戻り値でデータを受け渡しするのがおすすめです。
ifやforはブロックスコープを作らない
PHPでは、if、for、while、foreach などの通常の制御構文は、基本的に新しい変数スコープを作りません。
if (true) {
$message = "こんにちは";
}
echo $message;
このコードでは、if の中で定義した $message を外側でも参照できます。
出力は次のようになります。
こんにちは
for 文でも同じです。
for ($i = 0; $i < 3; $i++) {
$text = "ループ中";
}
echo $i;
echo $text;
この場合、$i や $text は for 文の外でも参照できます。
JavaScriptの let や const のようなブロックスコープとは挙動が異なるため、注意が必要です。
ブロックスコープを作るもの・作らないもの
PHPでは、制御構文と関数でスコープの扱いが異なります。
| 書き方 | 新しい変数スコープを作るか |
|---|---|
if | 基本的に作らない |
for | 基本的に作らない |
while | 基本的に作らない |
foreach | 基本的に作らない |
function | 作る |
| 無名関数 | 作る |
| アロー関数 | 作る |
| メソッド | 作る |
つまり、PHPでは通常の制御構文よりも、関数・メソッド・クロージャでスコープが分かれると考えると理解しやすいです。
foreachの変数スコープ
PHPでは、foreach で使った変数もループ後に残ります。
$items = ["A", "B", "C"];
foreach ($items as $item) {
echo $item;
}
echo $item;
最後の echo $item; では、最後に代入された "C" が表示されます。
$items = ["A", "B", "C"];
foreach ($items as $item) {
echo $item;
}
echo $item; // C
このように、foreach のループ変数は、ループが終わってもスコープから消えません。
参照付きforeachではunset()が重要
foreach で参照渡しを使う場合は、特に注意が必要です。
$numbers = [1, 2, 3];
foreach ($numbers as &$number) {
$number *= 2;
}
このコードでは、配列の各要素を2倍にしています。
処理後の $numbers は次のようになります。
[2, 4, 6]
ただし、参照付き foreach のあと、$number は最後の要素への参照を持ったままになります。
その状態で同じ変数名を使うと、意図しない書き換えが起きることがあります。
$numbers = [1, 2, 3];
foreach ($numbers as &$number) {
$number *= 2;
}
// unset($number); をしていない
foreach ($numbers as $number) {
echo $number . PHP_EOL;
}
参照付き foreach を使ったあとは、次のように unset() して参照を切るのが安全です。
$numbers = [1, 2, 3];
foreach ($numbers as &$number) {
$number *= 2;
}
unset($number);
この unset($number); は、配列の要素を削除するのではなく、変数 $number と最後の要素との参照関係を切るために使います。
関数の引数とスコープ
関数の引数は、その関数内で使えるローカル変数として扱われます。
function greet($name) {
echo "こんにちは、" . $name . "さん";
}
greet("佐藤");
この $name は、関数 greet() の中だけで有効です。
外側に同じ名前の変数があっても、基本的には別の変数です。
$name = "田中";
function greet($name) {
echo $name;
}
greet("佐藤");
echo $name;
出力は次のようになります。
佐藤田中
関数内の $name には "佐藤" が入り、関数外の $name は "田中" のままです。
値渡し
PHPの関数引数は、通常は値渡しです。
function changeName($name) {
$name = "佐藤";
}
$name = "田中";
changeName($name);
echo $name;
この場合、出力は次のようになります。
田中
関数内で $name を変更しても、外側の $name は変更されません。
参照渡し
外側の変数そのものを変更したい場合は、引数に & を付けます。
function changeName(&$name) {
$name = "佐藤";
}
$name = "田中";
changeName($name);
echo $name;
出力は次のようになります。
佐藤
&$name とすることで、関数内の変更が外側の変数にも反映されます。
ただし、参照渡しを多用すると、どこで値が変わったのか追いにくくなります。
実務では、できるだけ戻り値を使うほうが読みやすいです。
function changeName($name) {
return "佐藤";
}
$name = "田中";
$name = changeName($name);
echo $name;
static変数とは？
通常、関数内のローカル変数は、関数の実行が終わると破棄されます。
function countUp() {
$count = 0;
$count++;
echo $count . PHP_EOL;
}
countUp();
countUp();
countUp();
出力は次のようになります。
1
1
1
毎回 $count = 0; から始まるため、常に 1 が表示されます。
一方、static を使うと、関数の実行後も値を保持できます。
function countUp() {
static $count = 0;
$count++;
echo $count . PHP_EOL;
}
countUp();
countUp();
countUp();
出力は次のようになります。
1
2
3
static $count = 0; は最初の1回だけ初期化され、その後は前回の値を保持します。
static変数の使いどころ
static 変数は、関数内で前回の値を覚えておきたい場合に使えます。
function generateId() {
static $id = 0;
$id++;
return "ID-" . $id;
}
echo generateId(); // ID-1
echo generateId(); // ID-2
echo generateId(); // ID-3
ただし、static 変数は関数内部に状態を持つため、使いすぎるとテストやデバッグが難しくなることがあります。
必要な場面に絞って使うのがよいでしょう。
クロージャのスコープ
PHPでは、無名関数を変数に代入できます。
このような無名関数は、クロージャとも呼ばれます。
$hello = function () {
echo "こんにちは";
};
$hello();
クロージャも関数なので、外側の変数をそのまま参照することはできません。
$name = "佐藤";
$hello = function () {
echo $name;
};
$hello();
このコードでは、クロージャ内の $name は未定義です。
外側の変数をクロージャ内で使うには、use を使います。
$name = "佐藤";
$hello = function () use ($name) {
echo "こんにちは、" . $name . "さん";
};
$hello();
出力は次のようになります。
こんにちは、佐藤さん
useは基本的に値をコピーする
クロージャの use は、基本的に値渡しです。
$name = "佐藤";
$hello = function () use ($name) {
echo $name;
};
$name = "田中";
$hello();
出力は次のようになります。
佐藤
クロージャを作った時点の $name が取り込まれるため、その後に外側の $name を変更しても、クロージャ内の値は変わりません。
参照として取り込む場合
外側の変数の変更をクロージャにも反映させたい場合は、& を付けて参照として取り込みます。
$name = "佐藤";
$hello = function () use (&$name) {
echo $name;
};
$name = "田中";
$hello();
出力は次のようになります。
田中
use (&$name) とすることで、外側の $name を参照として取り込めます。
アロー関数のスコープ
PHP 7.4以降では、アロー関数を使えます。
$taxRate = 0.1;
$calcTax = fn($price) => $price * $taxRate;
echo $calcTax(1000);
アロー関数では、式の中で使われた外側の変数が自動的に取り込まれます。
通常の無名関数で書くと、次のようになります。
$taxRate = 0.1;
$calcTax = function ($price) use ($taxRate) {
return $price * $taxRate;
};
アロー関数を使うと、use ($taxRate) を書かなくても済みます。
$calcTax = fn($price) => $price * $taxRate;
ただし、アロー関数は外側の変数を値渡しで取り込みます。
$count = 1;
$fn = fn() => $count;
$count = 2;
echo $fn();
出力は次のようになります。
1
アロー関数を作った時点の $count が取り込まれるため、その後に外側の $count を変更しても、アロー関数内の値は変わりません。
アロー関数では外側の変数を直接変更できない
次のコードを見てください。
$count = 1;
$fn = fn() => $count++;
$fn();
echo $count;
この場合、外側の $count は変更されません。
アロー関数は外側の変数を値として取り込むため、外側の変数そのものを変更する用途には向いていません。
外側の変数を変更したい場合は、通常のクロージャで参照渡しを使います。
$count = 1;
$fn = function () use (&$count) {
$count++;
};
$fn();
echo $count; // 2
スーパーグローバル変数とは？
PHPには、関数内でも global を書かずに参照できる特別な変数があります。
これをスーパーグローバル変数といいます。
代表的なものは次の通りです。
| 変数 | 内容 |
|---|---|
$_GET | URLのクエリパラメータ |
$_POST | POST送信されたデータ |
$_REQUEST | GET、POST、COOKIEなどの値 |
$_SERVER | サーバー情報やリクエスト情報 |
$_SESSION | セッション情報 |
$_COOKIE | Cookie情報 |
$_FILES | アップロードファイル情報 |
$_ENV | 環境変数 |
$GLOBALS | グローバル変数一覧 |
たとえば、関数内でも $_GET を直接参照できます。
function showId() {
echo $_GET['id'];
}
スーパーグローバルを使うときの注意点
実務では、スーパーグローバルのキーが存在するかどうかを確認する必要があります。
$id = $_GET['id'] ?? null;
また、$_GET や $_POST はユーザーが送信した値なので、必ず検証やエスケープを行う必要があります。
$id = $_GET['id'] ?? null;
if ($id !== null) {
echo htmlspecialchars($id, ENT_QUOTES, 'UTF-8');
}
$_SESSION を使う場合は、通常は事前に session_start() を呼び出します。
session_start();
$_SESSION['user_id'] = 123;
スーパーグローバルは便利ですが、直接使いすぎるとテストしにくくなるため、実務では必要に応じてラップして扱うこともあります。
includeとrequireのスコープ
PHPでは、include や require を使って別ファイルを読み込めます。
このとき、読み込まれたファイルは、読み込まれた場所のスコープを引き継ぎます。
グローバルスコープで読み込む場合
main.php
$name = "佐藤";
include "profile.php";
profile.php
echo $name;
この場合、profile.php はグローバルスコープで読み込まれているため、$name を参照できます。
関数内で読み込む場合
function showProfile() {
$name = "佐藤";
include "profile.php";
}
showProfile();
profile.php
echo $name;
この場合、profile.php は関数 showProfile() の中で読み込まれているため、関数内の $name を参照できます。
つまり、include や require されたファイルのスコープは、読み込まれた場所によって変わります。
クラス内の変数とアクセス制御
PHPのクラスでは、プロパティやメソッドにアクセス修飾子を付けられます。
主なアクセス修飾子は次の3つです。
| 修飾子 | 意味 |
|---|---|
public | クラスの外からでもアクセスできる |
protected | そのクラス自身と子クラスからアクセスできる |
private | そのクラス自身からのみアクセスできる |
ただし、これは厳密には「変数スコープ」というより、クラスメンバーのアクセス制御です。
関数内のローカル変数とは少し別の概念として理解するとよいです。
public
class User {
public $name = "佐藤";
}
$user = new User();
echo $user->name;
public なプロパティは、クラスの外からアクセスできます。
private
class User {
private $password = "secret";
}
$user = new User();
echo $user->password;
このコードはエラーになります。
private なプロパティは、クラスの外から直接アクセスできません。
値を取得したい場合は、メソッドを通してアクセスします。
class User {
private $password = "secret";
public function getPassword() {
return $this->password;
}
}
$user = new User();
echo $user->getPassword();
protected
class User {
protected $role = "member";
}
class Admin extends User {
public function showRole() {
return $this->role;
}
}
$admin = new Admin();
echo $admin->showRole();
protected なプロパティは、そのクラス自身と子クラスの中からアクセスできます。
ただし、クラスの外から直接アクセスすることはできません。
echo $admin->role;
このコードはエラーになります。
$thisとプロパティの関係
クラスの中で、オブジェクト自身のプロパティにアクセスするには $this を使います。
class User {
private $name;
public function setName($name) {
$this->name = $name;
}
public function getName() {
return $this->name;
}
}
$user = new User();
$user->setName("佐藤");
echo $user->getName();
$this->name は、そのオブジェクトが持っている name プロパティを表します。
$this->nameと$this->$nameの違い
初心者がよく間違えるのが、次のような書き方です。
$this->$name
これは、name というプロパティにアクセスしているのではありません。
$name という変数の中身をプロパティ名として使う書き方です。
たとえば、次のような場合には有効です。
class User {
public $name = "佐藤";
public $email = "sato@example.com";
public function show($property) {
echo $this->$property;
}
}
$user = new User();
$user->show("email");
この場合、$property の中身は "email" なので、$this->$property は $this->email のように扱われます。
通常のプロパティアクセスでは、次のように書きます。
$this->name
動的にプロパティ名を指定したい場合だけ、次のように書きます。
$this->$property
staticプロパティとstaticメソッド
クラスには、インスタンスを作らずに使える static プロパティや static メソッドがあります。
class Counter {
public static $count = 0;
public static function increment() {
self::$count++;
}
}
Counter::increment();
echo Counter::$count;
出力は次のようになります。
1
クラス内でstaticプロパティにアクセスする場合は、self::$count のように書きます。
self::$count
通常のインスタンスプロパティは、次のように $this を使います。
$this->name
一方、staticプロパティは次のようにアクセスします。
self::$count
この違いは重要です。
名前空間と変数スコープの違い
PHPには namespace という仕組みがあります。
namespace App;
class User {
}
名前空間は、クラス名、関数名、定数名などの衝突を避けるための仕組みです。
一方、変数スコープは、変数をどこから参照できるかを決める仕組みです。
名前空間と変数スコープは関係がありますが、同じものではありません。
| 項目 | 役割 |
|---|---|
| 変数スコープ | 変数を参照できる範囲を決める |
| 名前空間 | クラス名・関数名・定数名などの衝突を防ぐ |
| アクセス修飾子 | クラスのプロパティやメソッドにアクセスできる範囲を決める |
初心者のうちは、この3つを分けて理解するとよいです。
PHPの変数スコープでよくあるミス
PHPの変数スコープを理解していないと、未定義変数や意図しない値の変更につながることがあります。
ここでは、よくあるミスを紹介します。
関数外の変数を関数内でそのまま使おうとする
$siteName = "My Blog";
function showSiteName() {
echo $siteName;
}
このコードでは、関数内の $siteName は未定義です。
修正するなら、引数で渡します。
$siteName = "My Blog";
function showSiteName($siteName) {
echo $siteName;
}
showSiteName($siteName);
globalに頼りすぎる
$db;
function getUser() {
global $db;
}
このようなコードは、関数が外部の $db に依存していることがわかりにくくなります。
より良い書き方は、必要な値を引数で渡すことです。
function getUser($db) {
// $dbを使って処理する
}
オブジェクト指向で書く場合は、コンストラクタで依存を渡す方法もあります。
class UserRepository {
private $db;
public function __construct($db) {
$this->db = $db;
}
}
参照付きforeachのあとにunset()しない
$numbers = [1, 2, 3];
foreach ($numbers as &$number) {
$number *= 2;
}
foreach ($numbers as $number) {
echo $number;
}
参照付き foreach のあとに同じ変数名を使うと、意図しない動作につながる可能性があります。
修正例は次のとおりです。
$numbers = [1, 2, 3];
foreach ($numbers as &$number) {
$number *= 2;
}
unset($number);
foreach ($numbers as $number) {
echo $number;
}
$this->nameと$this->$nameを混同する
class User {
private $name;
public function setName($name) {
$this->$name = $name;
}
}
このコードでは、意図したプロパティに値が入らない可能性があります。
通常は次のように書きます。
class User {
private $name;
public function setName($name) {
$this->name = $name;
}
}
$this->$name は、変数 $name の中身をプロパティ名として使う特殊な書き方です。
スーパーグローバルの値をそのまま使う
echo $_GET['id'];
このコードは、id が存在しない場合に警告が出る可能性があります。
また、ユーザー入力をそのまま出力すると、セキュリティ上の問題につながることもあります。
より安全に書くなら、次のようにします。
$id = $_GET['id'] ?? null;
if ($id !== null) {
echo htmlspecialchars($id, ENT_QUOTES, 'UTF-8');
}
スーパーグローバルは便利ですが、必ず存在確認・検証・エスケープを意識しましょう。
PHPの変数スコープを扱うときの実務的な考え方
PHPのスコープを扱うときは、次の方針を意識するとコードが読みやすくなります。
| 方針 | 理由 |
|---|---|
| 必要な値は引数で渡す | 関数の依存関係が明確になる |
結果は return で返す | データの流れがわかりやすい |
global はなるべく避ける | 外部状態への依存が見えにくくなる |
$GLOBALS を多用しない | コードの追跡が難しくなる |
| 参照渡しは必要な場合だけ使う | 予期しない副作用を防ぎやすい |
参照付き foreach の後は unset() する | 参照残りによるバグを防げる |
| スーパーグローバルは直接使いすぎない | テストや保守がしやすくなる |
クラスでは private を基本にする | オブジェクトの状態を安全に管理しやすい |
基本は「引数で受け取り、戻り値で返す」
実務では、次のような考え方を基本にすると安全です。
function 関数名($必要な値) {
// ローカル変数で処理する
return $結果;
}
つまり、必要な値は引数で受け取り、処理結果は戻り値で返すという考え方です。
この形にすると、関数が何に依存していて、何を返すのかが明確になります。
悪い例と良い例
ここでは、PHPの変数スコープを踏まえた悪い例と良い例を比較します。
悪い例
$taxRate = 0.1;
function calculateTotal($price) {
global $taxRate;
return $price + ($price * $taxRate);
}
echo calculateTotal(1000);
このコードは動きます。
しかし、calculateTotal() が $taxRate に依存していることが、関数の定義だけではわかりにくいです。
良い例
function calculateTotal($price, $taxRate) {
return $price + ($price * $taxRate);
}
echo calculateTotal(1000, 0.1);
この書き方なら、関数に必要な値が明確です。
さらに実務向けの例
class PriceCalculator {
private $taxRate;
public function __construct($taxRate) {
$this->taxRate = $taxRate;
}
public function calculateTotal($price) {
return $price + ($price * $this->taxRate);
}
}
$calculator = new PriceCalculator(0.1);
echo $calculator->calculateTotal(1000);
税率をオブジェクトの状態として持たせることで、関連する処理をクラス内にまとめられます。
PHPの変数スコープの重要ポイント
最後に、PHPの変数スコープで特に重要なポイントを整理します。
| 場所・機能 | スコープの考え方 |
|---|---|
| 関数外の変数 | グローバルスコープに属する |
| 関数内の変数 | ローカルスコープに属する |
| 関数の引数 | 関数内のローカル変数として扱われる |
if / for / while | 基本的に新しい変数スコープを作らない |
foreach | ループ変数はループ後も残る |
global | グローバル変数を関数内で使うためのキーワード |
$GLOBALS | グローバル変数を配列として参照できる |
static 変数 | 関数の実行後も値を保持する |
| クロージャ | 外側の変数を使うには通常 use が必要 |
| アロー関数 | 使用した外側の変数を自動的に値渡しで取り込む |
| スーパーグローバル | 関数内でも global なしで参照できる |
| クラスプロパティ | public、protected、private によって可視性が決まる |
PHPの変数スコープについてのまとめ
PHPの変数スコープで最も重要なのは、関数の外で定義した変数は、関数の中からそのまま参照できないという点です。
$var = "外側";
function test() {
echo $var; // 関数内では未定義
}
関数内で外側の値を使いたい場合は、基本的には引数で渡します。
$var = "外側";
function test($var) {
echo $var;
}
test($var);
global や $GLOBALS を使う方法もありますが、実務では依存関係が見えにくくなるため、必要な場面に限定するのがよいでしょう。
また、PHPでは if や for は基本的にブロックスコープを作りません。
一方で、関数、メソッド、クロージャは独立したスコープを持ちます。
さらに、クロージャでは use、アロー関数では自動的な値渡し、クラスでは public / protected / private によるアクセス制御など、場面によってスコープの考え方が変わります。
PHPのスコープを正しく理解しておくと、未定義変数の警告、意図しない値の上書き、global への依存、参照付き foreach のバグなどを防ぎやすくなります。
実務では、必要な値は引数で受け取り、処理結果は戻り値で返すという考え方を基本にすると、PHPのコードは読みやすく、保守しやすくなります。
以上、PHPの変数のスコープについてでした。
最後までお読みいただき、ありがとうございました。
