【PHP8.x】ParentIterator::hasChildren()メソッドの使い方

Copy
1<?php
2
3/**
4 * RecursiveArrayIterator と ParentIterator を使用して、
5 * 要素が子を持つかどうかを判断するサンプルコードです。
6 *
7 * システムエンジニアを目指す初心者の方にも分かりやすいように、
8 * PHPのイテレータとParentIterator::hasChildren()メソッドの基本的な使い方を示します。
9 */
10
11// テスト用の多次元配列データ
12// この配列は、子要素を持つグループ（'group1', 'sub_group1'）と、
13// 子要素を持たないグループ（'empty_group'）および単一の値（'item1', 'item2'）を含んでいます。
14$data = [
15    'item1' => 'value1',
16    'group1' => [
17        'sub_item1' => 'sub_value1',
18        'sub_group1' => [
19            'deep_item1' => 'deep_value1',
20        ],
21        'empty_group' => [], // このグループは子要素を持たないため、hasChildren() は false を返します
22    ],
23    'item2' => 'value2',
24];
25
26echo "--- ParentIterator::hasChildren() の使用例 ---\n\n";
27
28// 1. RecursiveArrayIterator を作成
29//    これは多次元配列を再帰的に走査するためのイテレータです。
30//    ParentIterator は RecursiveIterator インターフェースを実装したオブジェクトを
31//    コンストラクタに受け取るため、これを使用します。
32$recursiveIterator = new RecursiveArrayIterator($data);
33
34// 2. ParentIterator で RecursiveArrayIterator をラップ
35//    ParentIterator は RecursiveFilterIterator を継承しており、
36//    内部のイテレータの現在の要素が子要素を持つかどうかを判断するのに役立ちます。
37//    また、ParentIterator はデフォルトで、子要素を持つ要素のみをフィルタリングする挙動を持ちます。
38$parentIterator = new ParentIterator($recursiveIterator);
39
40// 3. RecursiveIteratorIterator を使用して、配列ツリー全体を再帰的に走査
41//    ParentIterator を RecursiveIteratorIterator のコンストラクタに渡すことで、
42//    ParentIterator のフィルタリングロジック（`accept()` メソッド）が適用され、
43//    同時に各要素の階層を深く探索できるようになります。
44//    RecursiveIteratorIterator::SELF_FIRST は、親要素を先に処理してから子要素に進むことを意味します。
45$iteratorIterator = new RecursiveIteratorIterator($parentIterator, RecursiveIteratorIterator::SELF_FIRST);
46
47// 各要素を走査
48foreach ($iteratorIterator as $key => $value) {
49    // 現在のイテレータの深さ（階層レベル）を取得し、インデントに使用
50    $currentLevel = $iteratorIterator->getDepth();
51    $indent = str_repeat("  ", $currentLevel);
52
53    // ParentIterator::hasChildren() メソッドを呼び出し、現在の要素が子要素を持つか確認
54    // RecursiveIteratorIterator の getInnerIterator() メソッドを介して、
55    // 現在のレベルの ParentIterator オブジェクトにアクセスし、その hasChildren() を呼び出します。
56    $currentParentIterator = $iteratorIterator->getInnerIterator();
57    $hasChildren = $currentParentIterator->hasChildren();
58
59    // 結果を出力
60    // 配列の場合は '[Array]' と表示し、それ以外は実際の値を出力します。
61    echo sprintf(
62        "%sKey: %s, Value: %s, Has Children (ParentIterator): %s\n",
63        $indent,
64        $key,
65        (is_array($value) ? '[Array]' : $value),
66        $hasChildren ? 'Yes' : 'No'
67    );
68}
69

PHP 8のParentIterator::hasChildren()メソッドは、イテレータが現在指している要素が子要素を持つかどうかを判断するために利用されます。このメソッドは引数を一切取らず、子要素が存在する場合はtrueを、存在しない場合はfalseを真偽値として返します。

このサンプルコードは、多次元配列を効率的に走査しながら、各要素が子要素を持っているかを確認する基本的な手順を示しています。まず、RecursiveArrayIteratorを用いて多次元配列をイテレータとして扱えるように準備します。次に、このRecursiveArrayIteratorをParentIteratorでラップすることで、子要素の有無を判断する機能を利用できるようにしています。

さらに、RecursiveIteratorIteratorを使用することで、配列の階層全体を再帰的に深く探索できるようになります。ループ内で$iteratorIterator->getInnerIterator()->hasChildren()を呼び出すと、現在処理している要素に子要素があるかどうかが判定されます。例えば、'group1'のように内部にさらに要素を持つものはtrueと判定され、'empty_group'のように子要素を持たない配列や、単一の値はfalseと判定されるため、配列の複雑な構造を理解し、条件に応じた処理を行う際にこのメソッドが大変役立ちます。

Copy
1<?php
2
3/**
4 * Demonstrates the usage of the ParentIterator::hasChildren() method in PHP 8.
5 *
6 * ParentIterator is a specialized iterator that filters another RecursiveIterator,
7 * only yielding elements that themselves have children (i.e., are parent nodes).
8 * Because of this filtering, when ParentIterator is valid and pointing to an element,
9 * its hasChildren() method will typically return true. A false return usually occurs
10 * when the iterator is not valid (e.g., empty data or at the end of iteration).
11 */
12function demonstrateParentIteratorHasChildren(): void
13{
14    // 1. Prepare a sample recursive data structure.
15    // 'Fruits' and 'Vegetables' are parents because they contain arrays (children).
16    // 'Citrus' is also a parent within 'Fruits'.
17    $data = [
18        'Fruits' => [
19            'Apple',
20            'Banana',
21            'Citrus' => [
22                'Orange',
23                'Lemon'
24            ]
25        ],
26        'Vegetables' => [
27            'Carrot',
28            'Potato'
29        ],
30        'Grains' => 'Wheat' // This is a leaf node (scalar value).
31                            // ParentIterator will filter this out as it has no children.
32    ];
33
34    // 2. Create a RecursiveArrayIterator for our data.
35    // This allows traversing the nested array structure.
36    $recursiveArrayIterator = new RecursiveArrayIterator($data);
37
38    // 3. Wrap the RecursiveArrayIterator in a ParentIterator.
39    // ParentIterator will only 'accept' and yield elements from $recursiveArrayIterator
40    // that themselves are arrays or objects with children.
41    $parentIterator = new ParentIterator($recursiveArrayIterator);
42
43    echo "--- Demonstrating ParentIterator::hasChildren() with valid elements ---\n";
44    echo "ParentIterator only yields elements that are themselves parents (have children).\n";
45    echo "Therefore, hasChildren() for these elements is typically true.\n\n";
46
47    // Iterate through the ParentIterator.
48    // For each element yielded, we check if the ParentIterator's current element has children.
49    foreach ($parentIterator as $key => $value) {
50        echo "Currently examining element at key: '{$key}'\n";
51
52        // Calling hasChildren() on the ParentIterator instance.
53        // This checks if the *current element* the iterator points to
54        // (e.g., 'Fruits', 'Vegetables', 'Citrus') has children in the underlying data.
55        if ($parentIterator->hasChildren()) {
56            echo "  -> ParentIterator::hasChildren() returns: true (The current item is a parent)\n";
57
58            // For deeper understanding, we can also retrieve and show its immediate children.
59            // This confirms why hasChildren() returned true.
60            echo "  -> Immediate children (via ParentIterator::getChildren()):\n";
61            foreach ($parentIterator->getChildren() as $childKey => $childValue) {
62                $type = is_array($childValue) ? 'Array' : 'Scalar';
63                $displayValue = $type === 'Scalar' ? ", Value: '{$childValue}'" : '';
64                echo "    - Child Key: '{$childKey}', Value Type: {$type}{$displayValue}\n";
65            }
66        } else {
67            // This 'else' block is generally not reached during normal iteration
68            // with ParentIterator because it's designed to only yield parents.
69            echo "  -> ParentIterator::hasChildren() returns: false (This is unexpected for a yielded element)\n";
70        }
71        echo "------------------------------------------------\n";
72    }
73
74    echo "\n--- Demonstrating ParentIterator::hasChildren() when the iterator is invalid ---\n";
75
76    // Create an empty iterator to illustrate a case where hasChildren() returns false.
77    $emptyRecursiveIterator = new RecursiveArrayIterator([]);
78    $emptyParentIterator = new ParentIterator($emptyRecursiveIterator);
79
80    // Before any valid element is found or if the iterator is empty, valid() is false.
81    if (!$emptyParentIterator->valid()) {
82        echo "ParentIterator is not valid (e.g., constructed with empty data).\n";
83        echo "Calling hasChildren() on an invalid iterator: ";
84        var_dump($emptyParentIterator->hasChildren()); // Expected output: bool(false)
85    } else {
86        echo "ParentIterator is unexpectedly valid for empty data. (This scenario should not occur).\n";
87    }
88}
89
90// Execute the demonstration function.
91demonstrateParentIteratorHasChildren();

PHP 8のParentIteratorクラスに属するhasChildren()メソッドは、現在イテレータが指している要素が子要素を持っているかどうかを判定するものです。このメソッドは引数を必要とせず、子要素を持っていればtrue、持っていなければfalseをブール値として返します。

ParentIteratorは、ネストされたデータ構造（例えば多次元配列）を扱うRecursiveIteratorから、子要素を持つ「親」の要素だけを抽出して処理するために使われる特別なイテレータです。そのため、ParentIteratorが有効な要素を指している場合、その要素は必ず子要素を持っているため、hasChildren()メソッドは通常trueを返します。サンプルコードでは、「Fruits」や「Citrus」といったキーを持つ要素が親である場合にtrueを返しているのが確認できます。

一方で、イテレータが空であったり、有効な要素を全く指していない場合には、hasChildren()はfalseを返します。このメソッドは、ツリー構造のような階層的なデータから親要素を効率的に見つけ出し、その子要素の有無を確認する際に非常に役立ちます。