递归函数从数据库结果生成多维数组

81

我正在寻找一个函数，该函数需要一个页面/类别的数组（来自平面数据库结果），并根据父ID生成一个嵌套页面/类别的数组。我想递归地执行此操作，以便可以进行任何级别的嵌套。

例如：我在一个查询中获取所有页面，这就是数据库表的样子

+-------+---------------+---------------------------+
|   id  |   parent_id   |           title           |
+-------+---------------+---------------------------+
|   1   |       0       |   Parent Page             |
|   2   |       1       |   Sub Page                |
|   3   |       2       |   Sub Sub Page            |
|   4   |       0       |   Another Parent Page     |
+-------+---------------+---------------------------+

这是我要最终在视图文件中处理的数组：

Array
(
    [0] => Array
        (
            [id] => 1
            [parent_id] => 0
            [title] => Parent Page
            [children] => Array
                        (
                            [0] => Array
                                (
                                    [id] => 2
                                    [parent_id] => 1
                                    [title] => Sub Page
                                    [children] => Array
                                                (
                                                    [0] => Array
                                                        (
                                                            [id] => 3
                                                            [parent_id] => 1
                                                            [title] => Sub Sub Page
                                                        )
                                                )
                                )
                        )
        )
    [1] => Array
        (
            [id] => 4
            [parent_id] => 0
            [title] => Another Parent Page
        )
)

我已经看过并尝试过几乎遇到的所有解决方案（Stack Overflow上有很多解决方案，但是没有运气得到足够通用的东西同时适用于页面和类别）。

这是我得到的最接近的，但是它不起作用，因为我正在将孩子分配给第一级父母。

function page_walk($array, $parent_id = FALSE)
{   
    $organized_pages = array();

    $children = array();

    foreach($array as $index => $page)
    {
        if ( $page['parent_id'] == 0) // No, just spit it out and you're done
        {
            $organized_pages[$index] = $page;
        }
        else // If it does, 
        {       
            $organized_pages[$parent_id]['children'][$page['id']] = $this->page_walk($page, $parent_id);
        }
    }

    return $organized_pages;
}

function page_list($array)
{       
    $fakepages = array();
    $fakepages[0] = array('id' => 1, 'parent_id' => 0, 'title' => 'Parent Page');
    $fakepages[1] = array('id' => 2, 'parent_id' => 1, 'title' => 'Sub Page');
    $fakepages[2] = array('id' => 3, 'parent_id' => 2, 'title' => 'Sub Sub Page');
    $fakepages[3] = array('id' => 4, 'parent_id' => 3, 'title' => 'Another Parent Page');

    $pages = $this->page_walk($fakepages, 0);

    print_r($pages);
}
php  arrays  function  recursion 
— 大卫·汉普希尔
source
1
您不能只使用所有parent_id的数组和页面的另一个数组吗？
— djot

Answers:

233

一些非常简单的通用树构建：

function buildTree(array $elements, $parentId = 0) {
    $branch = array();

    foreach ($elements as $element) {
        if ($element['parent_id'] == $parentId) {
            $children = buildTree($elements, $element['id']);
            if ($children) {
                $element['children'] = $children;
            }
            $branch[] = $element;
        }
    }

    return $branch;
}

$tree = buildTree($rows);

该算法非常简单：

  1. 取所有元素的数组和当前父对象的ID（最初是0/ nothing / null/ whatever）。
  2. 遍历所有元素。
  3. 如果parent_id元素的匹配您在1中获得的当前父ID，则该元素是父元素的子元素。将其放入您当前的孩子列表中（此处：）$branch。
  4. 用您刚刚在3.中标识的元素的ID递归调用函数，即找到该元素的所有子元素，并将它们添加为children元素。
  5. 返回找到的孩子列表。

换句话说，执行此函数将返回元素列表，这些元素是给定父ID的子元素。用调用它buildTree($myArray, 1)，它将返回具有父ID为1的元素的列表。最初，调用此函数的父ID为0，因此返回没有父ID的元素，它们是根节点。该函数以递归方式调用自身以找到孩子的孩子。

— 降低
source
1
很高兴能帮到您。需要注意的是：由于它总是$elements向下传递整个数组，因此效率较低。对于小型数组，这无关紧要，但是对于大型数据集，您需要在将其向下传递之前从中删除已匹配的元素。但是，这变得有些混乱，因此我将其简化以方便您理解。:)
— deceze
6
@deceze我也希望看到凌乱的版本。提前致谢！
— JensTörnell2013年
请问有人可以解释buildTree（）中第一个参数'array'是什么吗？那应该是您赋予页面等初始数组的var吗，例如'$ tree = array'？有人可以解释最后一行'$ tree = buildTree（$ rows）'，因为在任何地方都没有定义'$ rows'吗？最后，我正在努力地使用HTML标记来生成嵌套列表。
— Brownrice
1
@userarray是一个类型暗示为$elements，第一个参数是简单地array $elements。$rows是一组数据库结果，类似于问题中的结果。
— deceze
1
@user我添加了一个解释。忽略该$children = buildTree(...)部分，该功能应该非常明显和简单。
— deceze
13

我知道这个问题很旧，但是我面临着一个非常类似的问题-除了数据量很大。经过一番努力之后，我设法通过结果集的一遍构建树-使用引用。这段代码并不漂亮，但是它可以正常工作，并且运行很快。它是非递归的-也就是说，在结果集上只有一遍，最后是一遍array_filter：

$dbh = new PDO(CONNECT_STRING, USERNAME, PASSWORD);
$dbs = $dbh->query("SELECT n_id, n_parent_id from test_table order by n_parent_id, n_id");
$elems = array();

while(($row = $dbs->fetch(PDO::FETCH_ASSOC)) !== FALSE) {
    $row['children'] = array();
    $vn = "row" . $row['n_id'];
    ${$vn} = $row;
    if(!is_null($row['n_parent_id'])) {
        $vp = "parent" . $row['n_parent_id'];
        if(isset($data[$row['n_parent_id']])) {
            ${$vp} = $data[$row['n_parent_id']];
        }
        else {
            ${$vp} = array('n_id' => $row['n_parent_id'], 'n_parent_id' => null, 'children' => array());
            $data[$row['n_parent_id']] = &${$vp};
        }
        ${$vp}['children'][] = &${$vn};
        $data[$row['n_parent_id']] = ${$vp};
    }
    $data[$row['n_id']] = &${$vn};
}
$dbs->closeCursor();

$result = array_filter($data, function($elem) { return is_null($elem['n_parent_id']); });
print_r($result);

在此数据上执行时：

mysql> select * from test_table;
+------+-------------+
| n_id | n_parent_id |
+------+-------------+
|    1 |        NULL |
|    2 |        NULL |
|    3 |           1 |
|    4 |           1 |
|    5 |           2 |
|    6 |           2 |
|    7 |           5 |
|    8 |           5 |
+------+-------------+

最后print_r产生此输出：

Array
(
    [1] => Array
        (
            [n_id] => 1
            [n_parent_id] => 
            [children] => Array
                (
                    [3] => Array
                        (
                            [n_id] => 3
                            [n_parent_id] => 1
                            [children] => Array
                                (
                                )

                        )

                    [4] => Array
                        (
                            [n_id] => 4
                            [n_parent_id] => 1
                            [children] => Array
                                (
                                )

                        )

                )

        )

    [2] => Array
        (
            [n_id] => 2
            [n_parent_id] => 
            [children] => Array
                (
                    [5] => Array
                        (
                            [n_id] => 5
                            [n_parent_id] => 2
                            [children] => Array
                                (
                                    [7] => Array
                                        (
                                            [n_id] => 7
                                            [n_parent_id] => 5
                                            [children] => Array
                                                (
                                                )

                                        )

                                    [8] => Array
                                        (
                                            [n_id] => 8
                                            [n_parent_id] => 5
                                            [children] => Array
                                                (
                                                )

                                        )

                                )

                        )

                    [6] => Array
                        (
                            [n_id] => 6
                            [n_parent_id] => 2
                            [children] => Array
                                (
                                )

                        )

                )

        )

)

这正是我想要的。

— 亚历克斯G
source
虽然解决方案很聪明，但是此代码存在错误，但在不同情况下它给了我不同的结果
— Mohammadhzp 2015年
@Mohammadhzp去年，我一直在生产中使用此解决方案，对此没有任何问题。如果您的数据不同，您将得到不同的结果：）
— Aleks G 2015年
@AleksG：我在评论前赞成您的回答，我必须将isset（$ elem ['children']）添加到array_filter回调中，类似于此返回isset（$ elem ['children']）&& is_null（$ elem [' n_parent_id']）；使它正常工作
— Mohammadhzp 2015年
@Mohammadhzp进行更改后，如果顶级元素没有任何子代，则代码将不起作用-它将完全从数组中删除。
— Aleks G 2015年
@AleksG，使用最新版本的php不会对我产生什么影响，如果我删除isset（$ elem ['children']）并且顶层元素包含子元素，我将得到该顶层的两个不同数组元素（一个有孩子，一个没有孩子）“我刚刚在2分钟前再次测试，没有isset（）我得到了不同的（错误的）结果”
— Mohammadhzp 2015年
0

从这里的其他答案中得到启发，我想出了自己的版本，该方法通过使用自定义函数列表在每个级别上获取分组键，将assoc数组的数组 递归分组（到任意深度）。

这是原始的更复杂变体的简化版本（具有更多用于调整旋钮的参数）。请注意，它采用简单的迭代函数groupByFn作为子例程，以在各个级别上执行分组。

/**
 * - Groups a (non-associative) array items recursively, essentially converting it into a nested
 *   tree or JSON like structure. Inspiration taken from: https://stackoverflow.com/a/8587437/3679900
 * OR
 * - Converts an (non-associative) array of items into a multi-dimensional array by using series
 *   of callables $key_retrievers and recursion
 *
 * - This function is an extension to above 'groupByFn', which also groups array but only till 1 (depth) level
 *   (whereas this one does it till any number of depth levels by using recursion)
 * - Check unit-tests to understand further
 * @param array $data Array[mixed] (non-associative) array of items that has to be grouped / converted to
 *                    multi-dimensional array
 * @param array $key_retrievers Array[Callable[[mixed], int|string]]
 *                    - A list of functions applied to item one-by-one, to determine which
 *                    (key) bucket an item goes into at different levels
 *                    OR
 *                    - A list of callables each of which takes an item or input array as input and returns an int
 *                    or string which is to be used as a (grouping) key for generating multi-dimensional array.
 * @return array A nested assoc-array / multi-dimensional array generated by 'grouping' items of
 *               input $data array at different levels by application of $key_retrievers on them (one-by-one)
 */
public static function groupByFnRecursive(
    array $data,
    array $key_retrievers
): array {
    // in following expression we are checking for array-length = 0 (and not nullability)
    // why empty is better than count($arr) == 0 https://stackoverflow.com/a/2216159/3679900
    if (empty($data)) {
        // edge-case: if the input $data array is empty, return it unmodified (no need to check for other args)
        return $data;

        // in following expression we are checking for array-length = 0 (and not nullability)
        // why empty is better than count($arr) == 0 https://stackoverflow.com/a/2216159/3679900
    } elseif (empty($key_retrievers)) {
        // base-case of recursion: when all 'grouping' / 'nesting' into multi-dimensional array has been done,
        return $data;
    } else {
        // group the array by 1st key_retriever
        $grouped_data = self::groupByFn($data, $key_retrievers[0]);
        // remove 1st key_retriever from list
        array_shift($key_retrievers);

        // and then recurse into further levels
        // note that here we are able to use array_map (and need not use array_walk) because array_map can preserve
        // keys as told here:
        // https://www.php.net/manual/en/function.array-map.php#refsect1-function.array-map-returnvalues
        return array_map(
            static function (array $item) use ($key_retrievers): array {
                return self::groupByFnRecursive($item, $key_retrievers);
            },
            $grouped_data
        );
    }
}

请检查要点，以获取更多的数组实用程序功能以及单元测试

— y2k-shubham
source
-1

可以使用php将mysql结果放入数组，然后使用它。

$categoryArr = Array();
while($categoryRow = mysql_fetch_array($category_query_result)){
    $categoryArr[] = array('parentid'=>$categoryRow['parent_id'],
            'id'=>$categoryRow['id']);
   }
— 穆斯塔法
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.