第1回 PHP 8 上級 模擬試験

整数型(integer)は整数({..., -2, -1, 0, 1, 2, ...} という集合)を扱う。
整数のサイズはプラットフォームに依存するが、-2,147,483,648 ～ 2,147,483,647 (32bit符号付) または -9,223,372,036,854,775,808 ～ 9,223,372,036,854,775,807 (64bit符号付) である事が多い。
integer型の範囲外の数を指定した場合、floatとして解釈されるため、用途と環境によっては注意が必要である。

コールバック (callback) はPHP 5.4 以降では callable タイプヒントと呼ばれていた。
これには、あらゆるビルドイン関数、ユーザ定義関数、メソッド、静的なクラスメソッドが指定できるが、言語構造 (例：echo や empty、isset 等) は指定が出来ない。
コールバックに「オブジェクトのメソッド」を指定する場合、 配列の 0 番目の要素にオブジェクトを、 そして 1 番目の要素にメソッド名を指定する必要がある。
静的なクラスメソッドを指定する場合は、配列の 0 番目の要素にクラス名を、1 番目の要素にメソッド名を指定する必要がある。或いは 'ClassName::methodName' という形式で指定してもよい。
コールバック (callback) が使われる関数には usort() 関数がある。
そのため、以下のコード

class Hoge {
    public static function sort($a, $b) {
        return $a  $b;
    }
}

class Foo {
    public function sort($a, $b) {
        return $a  $b;
    }
}

$awk = [3, 1, 2];
usort($awk, [Hoge::class, 'sort']);
var_dump($awk);

$awk = [3, 1, 2];
usort($awk, 'Hoge::sort');
var_dump($awk);

$awk = [3, 1, 2];
usort($awk, [new Foo(), 'sort']);
var_dump($awk);

は正しく実行でき、結果は次のとおりとなる。

array(3) { 
  [0]=>
  int(1)
  [1]=>
  int(2)
  [2]=>
  int(3)
}

array(3) {
  [0]=>
  int(1)
  [1]=>
  int(2)
  [2]=>
  int(3)
}

array(3) {
  [0]=>
  int(1)
  [1]=>
  int(2)
  [2]=>
  int(3)
}

浮動小数点数 (float / double) は、小数を扱う。
浮動小数点数には精度があり、PHP では通常 IEEE 754 倍精度フォーマットが使われる。
浮動小数点数はどうしても誤差を考慮する必要があるため、例えば「小数を直接比較して等しいかどうかを調べてはいけない」という事を理解する必要がある。
そのため、以下のコード

if (0.3 === (0.1 + 0.2)) {
    echo "=>ここにはならない";
} else {
    echo "=>こちらになる";
}

論理型 (boolean) は「真偽値」とも呼ばれ、値は、true か false か null のいずれかになる。
なお、true、false、null の文字は、大文字で書いても小文字で書いてもよい。

三つの特別なキーワード self と parent そして static がクラス定義の内部からプロパティまたはメソッドにアクセスする際に使用される。
そのため、以下のコード

class Hoge {
    public function test_1() {
        echo __METHOD__, PHP_EOL;
    }

    public static function testStatic() {
        echo __METHOD__, PHP_EOL;
    }

    public static function staticCall() {
        self::testStatic();
        static::testStatic();
    }
}

class Foo extends Hoge {
    public function test_1() {
        parent::test_1();
        echo __METHOD__, PHP_EOL;
    }

    public static function testStatic() {
      echo __METHOD__, PHP_EOL;
    }
}

$obj = new Foo();
$obj->test_1();
Foo::staticCall();

を実行すると、結果は次のとおりとなる。

Hoge::test_1
Foo::test_1
Hoge::testStatic
Foo::testStatic

static メソッドはオブジェクトのインスタンスを生成せずにコールするため、疑似変数 $this は、 static として宣言されたメソッドの内部から利用することはできない。
そのため、以下のコード

class Hoge {
    public static function test() {
        var_dump($this);
    }
}

Hoge::test();

を実行すると、結果は次のとおりとなる。

Fatal error: Uncaught Error: Using $this when not in object context in ...

static プロパティは、矢印演算子 -> によりオブジェクトからアクセス することはできない。
そのため、以下のコード

class Hoge {
    static $i = 100;

    public function test() {
        echo $this->i;
    }
}

$obj = new Hoge();
$obj->test();

を実行すると、結果は次のとおりとなる。

Notice: Accessing static property Hoge::$i as non static in ...
Warning: Undefined property: Hoge::$i in ...

抽象クラスから継承する際、親クラスの宣言で abstract としてマークされた全てのメソッドは、子クラスで定義されなければならない。

また、これらのメソッドは同等(あるいはより緩い制約) の可視性で定義される必要がある。

一方でメソッドのシグネチャ(引数の型と順番)については、必須引数の数は同じである必要があるが、型宣言は異なってもかまわない。

そのため、以下のコード

abstract class Hoge {
    abstract public function __construct(string $s, array $a);
    protected $s;
    protected $a;
}

class Foo extends Hoge {
    public function __construct(string $s, ￥arrayObject $a) {
        $this->s = $s;
        $this->a = $a;
    }
}

$obj = new Foo('', new ￥arrayObject());
var_dump($obj);

は正しく実行でき、結果は次のとおりとなる。

object(Foo)#1 (2) {
  ["s":protected]=>
  string(0) ""
  ["a":protected]=>
  object(ArrayObject)#2 (1) {
    ["storage":"ArrayObject":private]=>
    array(0) {
    }
  }
}

PHPにおいて、コンストラクタは、__construct() メソッドで実装される。
そのため、以下のコード

class Hoge {
    public function __construct() {
        echo __METHOD__, PHP_EOL;
    }
}

$obj = new Hoge();

は正しく実行でき、結果は Hoge::__construct となる。

なお、コンストラクタを有している場合、親クラスのコンストラクタが暗黙の内にコールされることはない。
そのため、以下のコード

class Hoge {
    public function __construct() {
        echo __METHOD__, PHP_EOL;
    }
}

class Foo extends Hoge{
    public function __construct() {
        echo __METHOD__, PHP_EOL;
    }
}

$obj = new Foo();

を実行すると、結果は Foo::__construct となる。

親クラスのコンストラクタを実装する場合には、parent::をコールする事が必要となる。
そのため、以下のコード

class Hoge {
    public function __construct() {
        echo __METHOD__, PHP_EOL;
    }
}

class Foo extends Hoge{
    public function __construct() {
        parent::__construct();
        echo __METHOD__, PHP_EOL;
    }
}

$obj = new Foo();

を実行すると、結果は次のとおりとなる。

Hoge::__construct
Foo::__construct

PHPにおいて、デストラクタは、__destruct() メソッドで実装される。
そのため、以下のコード

class Hoge {
    public function __destruct() {
        echo __METHOD__, PHP_EOL;
    }
}

$obj = new Hoge();

は正しく実行でき、結果は Hoge::__destruct となる。

なお、デストラクタを有している場合、親クラスのデストラクタは、暗黙の内にコールされる。コールされる順番は「子クラスのデストラクタ → 親クラスのデストラクタ」の順番である。
そのため、以下のコード

class Hoge {
    public function __destruct() {
        echo __METHOD__, PHP_EOL;
    }
}

class Foo extends Hoge{
    public function __destruct() {
        echo __METHOD__, PHP_EOL;
    }
}

$obj = new Foo();

を実行すると、結果は次のとおりとなる。

Foo::__destruct
Hoge::__destruct

__call() マジックメソッドを使うと「アクセス不能なメソッドがオブジェクトのコンテキストで呼び出された時」に、処理を入れる事ができる。
そのため、以下のコード

class Hoge {
    public function __call(string $name, array $arguments) {
        echo "call: {$name}", PHP_EOL;
        var_dump($arguments);
        echo PHP_EOL;
    }
}

$obj = new Hoge();
$obj->test();
$obj->test2(1, '2', [3]);

は正しく実行でき、結果は次のとおりとなる。

call: test
array(0) {
}

call: test2
array(3) {
  [0]=>
  int(1)
  [1]=>
  string(1) "2"
  [2]=>
  array(1) {
    [0]=>
    int(3)
  }
}

__callStatic() マジックメソッドを使うと「アクセス不能なメソッドが静的コンテキストで呼び出された時」に、処理を入れる事ができる。

そのため、以下のコード

class Hoge {
    public static function __callStatic(string $name, array $arguments) {
        echo "call: {$name}", PHP_EOL;
        var_dump($arguments);
    }
}

Hoge::test(1, '2', [3]);

は正しく実行でき、結果は次のとおりとなる。

call: test
array(3) {
  [0]=>
  int(1)
  [1]=>
  string(1) "2"
  [2]=>
  array(1) {
    [0]=>
    int(3)
  }
}

なお、__callStatic() マジックメソッドが動くのは「静的コンテキストで呼び出された時」だけのため、「オブジェクトのコンテキストで呼び出された時」には動かない。
そのため、以下のコード

class Hoge {
    public static function __callStatic(string $name, array $arguments) {
        echo "call: {$name}", PHP_EOL;
        var_dump($arguments);
    }
}

$obj = new Hoge();
$obj->test();

を実行すると、結果は次のとおりとなる。

Fatal error: Uncaught Error: Call to undefined method Hoge::test() in ...

__toString() メソッドにより、クラスが文字列に変換される際の動作を決めることができる。
そのため、以下のコード

class Hoge {
    public function __toString() {
        return $this->s;
    }

    private $s = 'string';
}

$obj = new Hoge();
echo 'object: ' . $obj , PHP_EOL;

は正しく実行でき、結果は object: string となる。

また、__toString() メソッドで例外を投げる事は、PHP 7.3 までは出来なかったが、PHP 7.4 からは出来るようになった。
そのため、以下のコード

class Hoge {
    public function __toString() {
        throw new ￥Exception('*** test string ***');
    }

    private $s = 'string';
}

try {
    $obj = new Hoge();
    echo 'object: ' . $obj, PHP_EOL;
} catch(￥Throwable $e) {
    echo $e->getMessage(), PHP_EOL;
}

を実行すると *** test string *** となる。

__invoke() メソッドは、 スクリプトがオブジェクトを関数としてコールしようとした際にコールされる。
そのため、以下のコード

class Hoge {
    public function __invoke() {
        var_dump($this);
        return 'string';
    }
}

$obj = new Hoge();
$r = $obj();
var_dump($r);

は正しく実行でき、結果は次のとおりとなる。

object(Hoge)#1 (0) {
}
string(6) "string"

__get() は、アクセス不能 (protected または private) または存在しないプロパティからデータを読み込む際に使用する。
__getStatic() は存在せず、オブジェクトのコンテキスト、静的コンテキストのどちらでも動く。
そのため、以下のコード

class Hoge {
    public function __get(string $name) {
        return "not exist {$name}";
    }
}

$obj = new Hoge();
echo $obj->test, PHP_EOL;
echo Hoge::$test2, PHP_EOL;

は正しく実行でき、結果は次のとおりとなる。

not exist test
not exist test2

__debugInfo() メソッドが実装されていると、var_dump() でオブジェクトをダンプするときに出力するプロパティの情報を制御できる。
そのため、以下のコード

class Hoge {
    public function __debugInfo() {
        return [
            's' => $this->s,
            'i' => $this->i,
        ];
    }

    private $pass = 'password';
    private $s = 'string';
    private $i = 999;
}

$obj = new Hoge();
var_dump($obj);

は正しく実行でき、結果は次のとおりとなる。

object(Hoge)#1 (2) {
  ["s"]=>
  string(6) "string"
  ["i"]=>
  int(999)
}

PHP のリファレンスを使うと、ふたつの変数が同じ内容を指すようにできる。
そのため、以下のコード

$s = 'string';
$s2 = &$s;
$s2 = $s2 . ' add';
echo $s;

は正しく実行でき、結果は string add となる。

PHP のリファレンス渡しを使うと、関数内でその引数を修正可能になる。
リファレンス渡しは、呼び出す側で変数に & を付ける必要がある。
& を付けずに呼び出すと、リファレンス渡しにならない。
そのため、以下のコード

function hoge($s) {
    $s = $s . ' add hoge';
}

$s_hoge = 'string';
hoge($s_hoge);
hoge(&$s_hoge);
var_dump($s_hoge);

は正しく実行でき、結果は string(15) "string add hoge" となる。

PHPのリファレンス返しを使うと、関数の戻り値にリファレンスを指定する事が出来る。
リファレンス返しは、「関数の定義」と「代入」の双方に & を付ける必要がある。
そのため、以下のコード

class hoge {
    public function &test() {
        return $this->s;
    }

    private $s = 'string';
}

$obj = new Hoge();
$s = &$obj->test();
$s = $s . ' add';
var_dump($obj);

は正しく実行でき、結果は次のとおりとなる。

object(hoge)#1 (1) {
  ["s":"hoge":private]=>
  &string(10) "string add"
}

なお、マニュアルには「パフォーマンスを向上させるためだけの目的でこの機能を用いることはやめてください。そのようなことをしなくても、PHPエンジンが自動的に最適化を行います」と記されている。

リファレンスは、unset を使うことで解除する事が出来る。
そのため、以下のコード

$s = 'string';
$s2 = &$s;
$s2 = $s2 . ' add';
var_dump($s, $s2);
unset($s2);
$s2 = $s2 . ' add2';
var_dump($s, $s2);

を実行すると、次のとおりとなる。

string(10) "string add"
string(10) "string add"
Warning: Undefined variable $s2 in ...
string(10) "string add"
string(5) " add2"

名前空間は、namespace キーワードを使って宣言する。
名前空間の宣言は、通常他のコードより前にファイルの先頭で宣言をする必要がある。名前空間の宣言前に書かれたクラスなどは、宣言された名前空間には含まれない。
そのため、以下のコード

class Hoge {
}

namespace Name;

class Foo {
}

$obj = new Hoge();
var_dump($obj);

を実行すると、結果は次のとおりとなる。

Fatal error: Uncaught Error: Class 'Name￥Hoge' not found in ...

これはHogeがグローバル空間で宣言をされているためなので、以下のコード

class Hoge {
}

namespace Name;

class Foo {
}

$obj = new ￥Hoge();
var_dump($obj);

は正しく実行でき、結果は次のとおりとなる。

object(Hoge)#1 (0) {
}

名前空間は、namespace キーワードを使って宣言する。
また、名前空間はディレクトリやファイルと同様に、名前空間の階層構造を指定することができる。
そのため、以下のコード

namespace Name￥SubName;

class Hoge {
}

$obj = new Hoge();
var_dump($obj);

を実行すると、結果は次のとおりとなる。

object(Name￥SubName￥Hoge)#1 (0) {
}

名前空間の定義がない場合、すべてのクラスや関数の定義はグローバル空間に配置される。PHP で定義済みのクラスも、グローバル空間に配置される。
先頭に ￥ (バックスラッシュ) を付けると、名前空間の内部からであってもグローバル空間の名前を指定することができる。
そのため、以下のコード

namespace Name;

try {
    throw new Exception('error');
} catch (Exception $e) {
    echo 'in to catch';
}

を実行すると、結果は次のとおりとなる。

Fatal error: Uncaught Error: Class 'Name￥Exception' not found in ...

一方で以下のコード

namespace Name;

try {
    throw new ￥Exception('error');
} catch (￥Exception $e) {
    echo 'in to catch';
}

を実行すると in to catch となる。

PHP でのエイリアス作成には use 演算子を使用する。
use で指定する名前空間付きの名前の、先頭のバックスラッシュは不要で、推奨されない。
そのため、以下のコード

namespace Name;

class Hoge {
}

class Foo {
}

namespace Name￥Sub;

// よく使われているuse
use Name￥Hoge;

$obj = new Hoge();
var_dump(__NAMESPACE__, $obj);

namespace Name￥Sub2;

// エイリアスを切ったuse
use ￥name￥Hoge as Bar; // 先頭の ￥ は推奨されていない

echo PHP_EOL;
$obj = new Bar();
var_dump(__NAMESPACE__, $obj);

namespace Name￥Sub3;

// useのグループ化
use Name￥{Hoge, Foo};

echo PHP_EOL;
$hoge_obj = new Hoge();
$foo_obj = new Foo();
var_dump(__NAMESPACE__, $hoge_obj, $foo_obj);

は正しく実行でき、結果は次のとおりとなる。

string(8) "Name￥Sub"
object(Name￥Hoge)#1 (0) {
}

string(9) "Name￥Sub2"
object(Name￥Hoge)#2 (0) {
}

string(9) "Name￥Sub3"
object(Name￥Hoge)#1 (0) {
}
object(Name￥Foo)#2 (0) {
}

PHPで「何をエラーとして出力し、何をエラーとして出力しないか」の制御は、php.ini の error_reporting で行う。
プログラム実行時に ini_set() 関数を使っても設定できるが、error_reporting() という専用の関数も存在する。
ここには定数 (E_ERROR や E_NOTICE など) を、複数指定する場合はビット和演算子等をつかって指定する事が多い。値は int のため直接数値を入れてもよいが、定数を使う事が推奨されている。
定数には色々あるが、数値で 0 を指定すると「全てのエラー出力をオフにする」事ができる。
error_reporting() 関数で -1 を渡す事があるが、これは「将来のバージョンの PHP で新しいレベルと定数が追加されたとしてもすべてのエラーを表示するようになる (2の補数で、-1は「全てのbitが立つ」値になる)」という意味で使われる。
そのため、以下のコード

error_reporting(0);
$i++;
var_dump($i);

error_reporting(-1);
$j++;
var_dump($j);

を実行すると、結果は次のとおりとなる。

int(1)
Warning: Undefined variable $j in ...
int(1)

set_error_handler() を使うと、ユーザー定義のエラーハンドラ関数を設定する事ができる。
これを使うと「致命的なエラーの際になんらかの後処理が必要な場合」などにその処理を記述できる。
また、書き方によっては「PHP の標準関数のエラー時に、例外を投げる事」や「E_NOTICE であっても例外を投げる」事も可能である。
そのため、以下のコード

set_error_handler(
    function ($errno, $errstr, $errfile, $errline) {
        if (0 !== $errno & error_reporting()) {
            throw new ErrorException( $errstr, 0, $errno, $errfile, $errline);
        }
    }
);

try {
    $i++;
} catch(￥Throwable $e) {
    echo 'catch Exception', PHP_EOL;
    echo $e->getMessage(), PHP_EOL;
}

を実行すると、結果は次のとおりとなる。

catch Exception
Undefined variable $i

PHPのエラーのうち、E_ERRORは「重大な実行時エラー」、E_PARSE は「コンパイル時のパースエラー」となり、いずれもスクリプトの実行は中断される。
一方で、E_WARNING「実行時の警告 (致命的なエラーではない)」とE_NOTICE「実行時の警告」は、スクリプトの実行は中断されない。
そのため、以下のコード

$i++;
var_dump($i);
echo 'fin.';

を実行すると、結果は次のとおりとなる。

Warning: Undefined variable $i in ...
int(1)
fin.

PHP 5 において、Exception クラスは全ての例外の基底クラスであった。PHP 7 において、Exception クラスは「Throwable インタフェース」を基底クラスとしている。
また、PHP 7 以降において Error クラスという「PHP のすべての内部エラーの基底クラス」ができた。
そのため、以下のコード

try {
    throw new ￥Exception('Exception');
} catch(￥Throwable $e) {
    echo 'catch ' , $e->getMessage();
}

を実行すると、結果は catch Exception となる。
同様に、以下のコード

try {
    throw new ￥Error('Error');
} catch(￥Exception $e) {
    echo 'catch ' , $e->getMessage();
}

を実行すると、結果は catch Error となる。

Traversable インターフェイスは「そのクラスの中身が foreach を使用してたどれるかどうかを検出するインターフェイス」である。
これは抽象インターフェイスであり、単体で実装することはできず、 IteratorAggregate あるいは Iterator を実装しなければならない。
そのため、以下のコード

class Hoge implements Traversable {
}

を実行すると、結果は次のとおりとなる。

Fatal error: Class Hoge must implement interface Traversable as part of either Iterator or IteratorAggregate in Unknown on line 0

Iterator インターフェイスは「外部のイテレータあるいはオブジェクト自身から反復処理を行うためのインターフェイス」である。
また、Traversable を継承しているため foreach でも使う事ができる。
そのため、以下のコード

class Hoge implements Iterator {
    public function current() {
        $key = $this->key();
        if ('dummy' === $key) {
            return 'dummy value';
        }
        return $this->$key;
    }

    public function key() {
        return $this->keys[$this->position];
    }

    public function next() {
        $this->position ++;
    }

    public function rewind() {
        $this->position = 0;
    }

    public function valid() {
        return isset($this->keys[$this->position]);
    }

    public $s = 'string';
    public $i = 1;
    private $ps = 'string private';
    private $pi = 2;
    private $position = 0;
    private $keys = [ 'ps', 'i', 'dummy' ];
}

$obj = new Hoge();
foreach($obj as $k => $v) {
    echo "{$k} => {$v}￥n";
}

は正しく実行でき、結果は次のとおりとなる。

ps => string private
i => 1
dummy => dummy value

Countable インターフェイスを実装したクラスは、count() 関数で使用することができる。
そのため、以下のコード

class Hoge {
    public $s = 'string';
    public $i = 1;
    private $ps = 'private string';
    private $pi = 2;
}

$obj = new Hoge();
var_dump( count($obj) );

を実行すると、結果は次のとおりとなる。

Fatal error: Uncaught TypeError: count(): Argument #1 ($var) must be of type Countable|array, Hoge given in ...

一方で以下のコード

class Hoge implements Countable {
    public function count() {
        return 4;
    }

    public $s = 'string';
    public $i = 1;
    private $ps = 'private string';
    private $pi = 2;
}

$obj = new Hoge();
var_dump( count($obj) );

は正しく実行でき、結果は int(4) となる。

ArrayAccess インターフェイスは「配列としてオブジェクトにアクセスするための機能のインターフェイス」である。
そのため、以下のコード

class Hoge extends ArrayAccess {
    private $data = [
        's' => null,
        's2' => null,
        'i' => null,
        'j' => null,
    ];
}

$obj = new Hoge();
$obj['j'] = 999;
echo $obj['j'], PHP_EOL;
var_dump($obj);

は正しく実行でき、結果は次のとおりとなる。

999
object(Hoge)#1 (1) {
  ["data":"Hoge":private]=>
  array(4) {
    ["s"]=>
    NULL
    ["s2"]=>
    NULL
    ["i"]=>
    NULL
    ["j"]=>
    int(999)
  }
}

RecursiveDirectoryIterator クラスは、ファイルシステムのディレクトリを再帰的に反復処理するためのクラスである。
RecursiveDirectoryIterator クラスのオブジェクトをRecursiveIteratorIterator クラスで処理する事によって、RecursiveIteratorIterator クラスが「再帰的なイテレータの反復処理をする」ために、ファイルシステムのディレクトリを再帰的に反復処理する事が出来るようになる。
そのため、以下のコード

$dir = new RecursiveIteratorIterator(
           new RecursiveDirectoryIterator(__DIR__)
);

while($dir->valid()) {
    echo $dir->getPathname(), PHP_EOL;
    $dir->next();
}

は正しく実行でき、結果は次のような結果を得ることができる。

/home/phpexam/phpexam/.
/home/phpexam/phpexam/..
/home/phpexam/phpexam/dir/.
/home/phpexam/phpexam/dir/..
/home/phpexam/phpexam/dir/test
/home/phpexam/phpexam/sample.php

SplFileInfo クラスは、ファイルの情報取得のためのクラスである。
単純にファイル名や拡張子の他、inode 番号や inode 変更時刻、ファイルの所有者など、様々な情報を得る事ができるほか、SplFileObject クラスと同様のファイル操作も行う事ができる。
そのため、以下のコード

$file_info = new SplFileInfo(__FILE__);
echo $file_info->getFilename(), PHP_EOL;
echo $file_info->getInode(), PHP_EOL;
echo $file_info->fread(9999), PHP_EOL;

を実行すると、結果は次のとおりとなる。

sample.php
40318019
declare(strict_types=1);
error_reporting(-1);
$file_info = new SplFileInfo(__FILE__);
echo $file_info->getFilename(), PHP_EOL;
echo $file_info->getInode(), PHP_EOL;
echo $file_info->fread(9999), PHP_EOL;

SplFileObject クラスは、ファイルのためのオブジェクト指向のインターフェイスを提供する。
ファイルへの書き込みや読み込み、seek() メソッドでのファイルポインタの移動なども行うことができる。
そのため、以下のコード

$file = new SplFileObject(__FILE__);

while($line = $file->fgets()) {
    echo $line;
}

echo 'fin';

を実行すると、結果は次のとおりとなる。

$file = new SplFileObject(__FILE__);

while($line = $file->fgets()) {
    echo $line;
}

echo 'fin';
fin

SplTempFileObject クラスは、一時ファイルのためのオブジェクト指向のインターフェイスを提供する。
一時ファイルは「メモリまたはテンポラリファイル」上に作成される。
そのため、以下のコード

$file = new SplTempFileObject();
echo $file->getPathname();

を実行すると php://temp となる。

$_SERVER は、ヘッダ、パス、スクリプトの位置のような 情報を有する配列である。
この配列のエントリは Web サーバーにより生成されるため、PHP をコマンドラインで実行している場合には、使用できないものもある。
そのため、以下のコード

var_dump( $_SERVER['REMOTE_ADDR'] );

を Web サーバ経由で実行した場合は現在ページをみているユーザーの IP アドレスが出力されるが、コマンドラインから実行した場合は次のような結果となる。

Warning: Undefined array key "REMOTE_ADDR" in ...
NULL

$GLOBALS はグローバルスコープで使用可能なすべての変数への参照である。変数名が配列のキーとなる。そのため、以下のコード

function hoge() {
    var_dump( $GLOBALS['i'] );
}

$i = 999;
hoge();

は正しく実行でき、結果は次のとおりとなる。

int(999)

$argv はスクリプトに渡された引数の配列である。
$argv[0] はスクリプトの実行に使う名前となり、$argv[1] 以降に引数の配列が入る。そのため、

var_dump( $argv[1], $argv[2] );

上記のコードを

php sample.php aaa "bb cc dd" 999

のように呼び出すと、結果は次のとおりとなる。

string(3) "aaa"
string(8) "bb cc dd"

$_COOKIE は現在のスクリプトに HTTP クッキーから渡された変数の連想配列である。
Cookie から渡された値は $_COOKIE に入り、また $_COOKIE に設定した値は Cookie として設定される。そのため、以下のコード

$_COOKIE['i'] = ($_COOKIE['i'] ?? 0) + 1;
var_dump($_COOKIE['i']);

をブラウザから呼び出すと、1回目の結果は次のとおりとなる。

int(1)

2回目の結果は次のとおりとなる。

int(2)

3回目の結果は次のとおりとなる。

int(3)

配列の短縮構文 ([]) を使って、 代入用に配列の値を取り出せるようになった。
これは、list() の代替として使う事ができる(list() が無くなったわけではない)。そのため、以下のコード

$data = [
    [1, 2],
    [777, 999],
];

list($i, $j) = $data[0];
var_dump($i, $j);
[$i, $j] = $data[1];
var_dump($i, $j);

は正しく実行でき、結果は次のとおりとなる。

int(1)
int(2)
int(777)
int(999)

新しい擬似型 (callable と同じような型) である iterable が導入された。パラメータおよび返り値の型指定で使うことができ、「配列か、あるいは Traversable インターフェイスを実装したオブジェクトを受け付ける」ようになる。そのため、以下のコード

function hoge(iterable $itr) {
    var_dump($itr);
}

hoge([1, 2]);
hoge(new ArrayObject());

は正しく実行でき、結果は次のとおりとなる。

array(2) {
  [0]=>
  int(1)
  [1]=>
  int(2)
}
object(ArrayObject)#1 (1) {
  ["storage":"ArrayObject":private]=>
  array(0) {
  }
}

一方で以下のコード

function hoge(iterable $itr) {
    var_dump($itr);
}

$obj = new stdClass();
$obj->s = 'string';
$obj->i = 999;
hoge($obj);

を実行すると、結果は次のとおりとなる。

Fatal error: Uncaught TypeError: Argument 1 passed to hoge() must be iterable, object given, called in ...

数値形式ではない文字列を使って、数値を期待する演算 (+, -, *, /, **, %,  <<, >>, |, &, ^ や、これらを用いた代入演算) を行おうとしたときに、 E_WARNING あるいは E_NOTICE レベルのエラーが発生するようになった。そのため、以下のコード

$i = '11' + '22';
var_dump($i);

は正しく実行でき、結果は次のとおりとなる。

int(33)

一方で以下のコード

$i = '11' + 'a';
var_dump($i);

を実行すると、結果は次のとおりとなる。

Warning: A non-numeric value encountered in ...
int(11)

文字列操作関数 のうちオフセット指定のできるものすべてについて、負のオフセットを指定できるようになった。
[] や {} による 文字列への文字単位のアクセス についても同様となり、負のオフセットは、文字列の末尾からのオフセットと解釈される。
負の値を渡した場合、-0 が「文字列の末尾」となる。そのため、以下のコード

$s = 'abcdefg';
var_dump( $s[-1] );

は正しく実行でき、結果は次のとおりとなる。

string(1) "f"

PHP では、変数名を可変にする事ができる。そのため、以下のコード

declare(strict_types=1);
error_reporting(-1);

$test = 'hello';
$s = 'test';
echo $$s;

を実行すると、結果は次のとおりとなる。

hello

$を重ねて、2段以上の可変変数も、作ることは出来る。そのため、以下のコード

declare(strict_types=1);
error_reporting(-1);

$test = 'hello';
$s = 'test';
$ss = 's';
echo $$ss, PHP_EOL;
echo $$$ss;

を実行すると、結果は次のとおりとなる。

test
hello

可変変数は、PHP 5 と PHP 8 で評価の順番が異なる。
例えば「$$foo['bar']['baz']」という可変変数がある場合、PHP 5 では「${$foo['bar']['baz']}」、PHP 7 以降では「($$foo)['bar']['baz'] (PHP 5 でもパース可能な記法だと ${$foo}['bar']['baz']」と解釈される。そのため、以下のコード

// declare(strict_types=1);
error_reporting(-1);

$awk['bar']['baz'] = 'aaa';
$foo = 'awk';
var_dump($$foo['bar']['baz']);
$foo2['bar']['baz'] = 'bbb';
$bbb = 'awk';
var_dump($$foo2['bar']['baz']);

を PHP 8 で実行すると、結果は次のとおりとなる。

string(3) "aaa"
Warning: Array to string conversion in ...
Warning: Undefined variable $Array in ...
Warning: Trying to access array offset on value of type null in ...
Warning: Trying to access array offset on value of type null in ...
NULL

一方で PHP 5 で実行すると、結果は次のとおりとなる。

Warning: Illegal string offset 'bar' in ...
Warning: Illegal string offset 'baz' in ...
Notice: Undefined variable: a in ...
NULL
string(3) "awk"

そのため、波括弧 {} を使って「評価順番を明示的に書く」と、バージョンによらず互換性を保つ事ができる。

可変変数は、スーパーグローバル変数に対しても使う事ができる。そのため、以下のコード

declare(strict_types=1);
error_reporting(-1);

function hoge() {
    $s = '_ENV';
    echo ${$s}['SSH_TTY'], PHP_EOL;
}

echo $_ENV['SSH_TTY'], PHP_EOL;
hoge();

を実行すると、結果は次のとおりとなる。

/dev/pts/1
/dev/pts/1

クラスのプロパティは、新たに型宣言をサポートするようになった。そのため、以下のコード

class Hoge {
    public int $i;
}

$obj = new Hoge();
$obj->i = 'string';

を実行すると、結果は次のとおりとなる。

Fatal error: Uncaught TypeError: Typed property Hoge::$i must be int, string used in  ...

アロー関数は、暗黙的な値スコープを持った関数を定義する簡便な文法を提供する。
また、アロー関数は親のスコープで使える変数が常に自動で使える。そのため、以下のコード

$x = 11;
$fn = fn($i) => $i * $x;
var_dump($fn);
var_dump( $fn(9) );

は正しく実行でき、結果は次のとおりとなる。

object(Closure)#1 (1) {
  ["parameter"]=>
  array(1) {
    ["$i"]=>
    string(10) ""
  }
}
int(90)

Null の場合の代入演算子が追加された。そのため、以下のコード

$array = ['key' => 1];
$array['key'] ??= 'default';
$array['key2'] ??= 'default';
var_dump($array);

は正しく実行でき、結果は次のとおりとなる。

array(2) {
  ["key"]=>
  int(1)
  ["key2"]=>
  string(7) "default"
}

波括弧を使って配列や文字列のオフセットにアクセスする文法は推奨されなくなった。そのため、以下のコード

$s = 'abc';
var_dump( $s{1} );

を実行すると、結果は次のとおりとなる。

Parse error: syntax error, unexpected '}', expecting ']' in  ...

PHP 8 では、nullsafe 演算子がサポートされた。そのため、以下のコード

class Hoge {
    public function f1() {
        echo __METHOD__, PHP_EOL;
        return $this;
    }

    public function f2() {
        echo __METHOD__, PHP_EOL;
        return null;
    }

    public function f3() {
        echo __METHOD__, PHP_EOL;
        return $this;
    }
}

$val = (new Hoge())?->f1()?->f2()?->f3();
var_dump($val);

を実行すると、結果は次のとおりとなる。

Hoge::f1
Hoge::f2
NULL

PHP 8 では、(厳密でないやり方で) 数値と非数値文字列を比較する場合、数値を文字列にキャストし、文字列と比較するようになった。そのため、以下のコードを

var_dump( 2 == '2' );
var_dump( 0 == '0' );
var_dump( 2 == '2a' );
var_dump( 0 == '' );
var_dump( 0 == 'foo' );

PHP 7.4 で動かすと、結果は次のとおりとなる。

bool(true)
bool(true)
bool(true)
bool(true)
bool(true)

PHP 8.0 で動かすと、結果は次のとおりとなる。

bool(true)
bool(true)
bool(false)
bool(false)
bool(false)

private なメソッドは「継承されない」はずだが、PHP 7 では親のメソッドと同じ名前のメソッドは、親のメソッドの可視性に関係なく、一部の継承ルールがチェックされていたが、これが PHP 8 では変更された。そのため、以下のコードを

class Hoge {
    final private function pFunc1() {
        echo __METHOD__, PHP_EOL;
    }
}

class Foo extends Hoge {
    private function pFunc1() {
        parent::pFunc1();
        echo __METHOD__, PHP_EOL;
    }

    public function callPri() {
        $this->pFunc1();
    }
}

(new Foo())->callPri();

PHP 7.4 で動かすと、結果は次のとおりとなる。

PHP Fatal error:  Cannot override final method Hoge::pFunc1() in ...

PHP 8.0 で動かすと、結果は次のとおりとなる。

Hoge::pFunc1
Foo::pFunc1

PHP 8 では、インタンスに対する ::class がサポートされた。そのため、以下のコードを

class Hoge {
}

var_dump( Hoge::class );
$obj = new Hoge();
var_dump( $obj::class );

PHP 7.4 で動かすと、結果は次のとおりとなる。

PHP Fatal error:  Cannot use ::class with dynamic class name in ...

PHP 8.0 で動かすと、結果は次のとおりとなる。

string(4) "Hoge"
string(4) "Hoge"

PHP の制御構造 (if, while, for, foreach, switch) では、波括弧 {} の変わりに「開き波括弧をコロン(:)、閉じ波括弧をそれぞれ endif;, endwhile;, endfor;, endforeach;, endswitch; に変更する」事が出来る。そのため、以下のコード

<?php
$i = 10;

if ($i > 9) : ?>
    $i は9より大きい

    $i は9以下

を実行すると、結果は次のとおりとなる。

    $i は9より大きい

break は、現在実行中の for, foreach, while, do-while, switch 構造の実行を終了する。そのため、以下のコード

for($i = 0; $i < 10; ++$i) {
    echo "{$i}￥n";
    break;
}

を実行すると、結果は次のとおりとなる。

0

break は、現在実行中の for, foreach, while, do-while, switch 構造の実行を終了する。
また、break ではオプションの引数でネストしたループ構造を抜ける数を指定することができる。
いくつかネストしているループの内側で「その全てのループを抜け出したい」場合、大きな値をとりあえず入れておくとよい。そのため、以下のコード

$i = $j = 0;

while($i < 10) {
    echo "i is {$i}", PHP_EOL;
    $i ++;

    while($j < 10) {
        echo "j is {$j}", PHP_EOL;
        $j ++;
        break 999;
    }
}

を実行すると、結果は次のとおりとなる。

i is 0
j is 0

continue は、ループ構造 (for, foreach, while, do-while) において現在の繰り返しループ の残りの処理をスキップし、条件式を評価した後に 次の繰り返しの最初から実行を続けるために使用される。
PHP 7.3 以降、switch 内部で break 文のように振る舞おうとする continue については、E_WARNING をトリガーするようになった。そのため、以下のコード

$i = 2;

switch($i) {
    case 0:
    case 1:
        echo "i is {$i}￥n";
        continue;
    default:
        echo "i is {$i}: final￥n";
        continue;
}

PHP 7.2 までであれば、結果は次のとおりとなる。

i is 2: final

PHP 7.3 以降は、結果は次のとおりとなる。

Warning: "continue" targeting switch is equivalent to "break". Did you mean to use "continue 2"? in ....

HTML の動的な生成において、実装に問題があるとXSS 脆弱性が発生する。
そのためには、適切な引数で htmlspecialchars() 関数、または htmlentities() 関数を使う必要がある。
そのため、以下のコード

$input = "alert('test');";
$e_input = htmlspecialchars($input, ENT_QUOTES, 'UTF-8');
echo $e_input;

を実行すると

alert('test');

となり、必要なエスケープが全てなされているので、XSSを防ぐ事ができる。

以下のコード

$e_test = htmlspecialchars(filter_input(INPUT_GET, 'test'), ENT_QUOTES, 'UTF-8');
echo "{$e_test}
";

によって、適切に入力がエスケープされるため XSS を防ぐ事ができる。
ただし、もしパラメタ test に配列が入ってきている場合、またはパラメタ test が存在しない場合は、filter_input() 関数の戻り値の仕様が成功した場合は要求された変数の値、フィルタリングに失敗した場合に false、 あるいは変数 var_name が設定されていない場合に null を返します。
であるため、結果は次のとおりとなる。

Fatal error: Uncaught TypeError: htmlspecialchars(): Argument #1 ($string) must be of type string, null given in ...

以下のコード

$val = $_GET['test'] ?? '';

if ( is_string($val) ) {
    $ret = htmlentities($val, ENT_QUOTES, 'UTF-8');
    echo "{$ret}
";
} else {
    foreach($val as $v) {
        echo "{$v}
";
    }
}

をブラウザ経由で実行すると、test に文字列が入ってきても配列が入ってきても、適切に XSS 対策を行う事ができる。

$_GET['test'] に文字列で任意のユーザ入力が入っている (配列ではない) とした時に、以下のコード

$ret = htmlspecialchars($_GET['test'], ENT_COMPAT);
echo "{$ret}
";

をブラウザ経由で実行すると、シングルクオートが変換されないため、XSS が発生する可能性がある。この実装は適切ではない。