Unable to access. You may not have permission to use network resources. Post some ideas on how to implement unlimited classification in PHP~

1. Those who build websites generally encounter the problem of processing classifications. I will post a few examples of processing unlimited classifications. The structure of the database is very simple:
id, fatcher_id, name, ...
Such a design is short and concise. It fully meets 3NF. It can meet most of the requirements. OK, let us take a look at the program implementation under this database structure.
1. Recursive query of the database
The most terrible method ~ is also the best way to implement it
　 Category 1
Category 1.1
　　 Category 1.1.1
　　 Category 1.2
　 Category 2
　 Category 2.1
　 Category 3
　 Category 3.1
　　 Category 3.2
......
In order to generate such a directory structure, the program recursively queries the database once. When you Anywhere that involves classification (page turning, query...), the database will tragically operate the hard disk...Amen~so~let's jump...
2. Query the database once, and the recursive array will generate the above directory structure
Post a general idea
function SelectList(&$Data, $RootID = 0')
{
for($i = 0; $i {
if($Data[ $i]['UID'] == $RootID)
                                                                                                                                                    $ i] ['ID'], $ Blank, $ Match);
}}}
Return $ this-& gt; output;
}
This intensity is enough Yes, there are several K or even W categories. The recursion may take more than 100 milliseconds. Considering concurrency... Haha~ Let’s jump again
3. Query the database once and generate the directory structure non-recursively
This Step one, here comes the trick of the program~ It only needs to traverse the results once to generate the directory structure like the one above. It is very convenient to format it into the display style of a web page~ The following is written by someone else. I have tried it and it is completely feasible
function GetArray($RootID = 0)
{
$Data = array();
$Data = $tblObj->MapResult($tblObj->Select());
$Output = Array();
$i = 0;
$len = Count($Data);
if($RootID)
{ while($Data[$i]['UID'] != $RootID && $i }
$UpID = $RootID; //The category parent ID pointed to by the previous node
for($cnt = Count($Data); $i {
j = 0; // Initialize the classification of the classification data counting
iF ($ upid == $ rootid) // Save all first -level classification in the array of $ OUTPUT in the first cycle. Data[$i]['UID'] == $UpID && $i                                                                                                 /Save the node to the Output array
$ TMP [$ Data [$ i] ['ID']] = & $ OUTPUT [$ J]; // and save the node ID in the position of Output.
$i++;
                                               
                                                                                                                                                                                                                                                   
                                                                                                   ]['Child'][$j] = $Data[$i];
                            $tmp[$Data[$i]['ID']] = &$tmp[$UpID]['Child'][$j | = $Data[$i]['UID'];
}
return $Output;
}
The program looks so tiring~ The efficiency of this code is more than ten times faster than the previous one, and the intensity is strong enough...
However...90% of websites using this code are wasted~ The website classifications I have come across are generally below level four. So, can it be further optimized?... Let's jump again...
4. Start with the database~
A little bit Change the structure of the database and add a redundant field for layer. This was thought up by a db desing expert. I just posted it
id name father_id layer
1 Total category 0 000000
2 Category 1 1 010000
3 Category 1.1 1 Category 2.1 5 020100
7 Category 3 1 030000
8 Category 3.1 7 0301 00
9 Category 3.2 7 030200
10 Category 1.1.1 3 010101
Now press layer Let’s search the size of Category 1 1 010000
3 Category 1.1 2 010100
10 Category 1.1.1 3 010101
4 Category 1.2 2 010200
5 Category 2 1 020000
6 Category 2.1 5 020100
7 Category 3 1 030000
8 Category 3.1 7 030100
9 Category 3.2 7 030200
Did you see it? Even the directory structure is generated in one query. This makes the program much easier. It just requires more work to maintain the layer field. In this routine, the layer field can handle 99 categories at each level. If there is BT Application, just change it to a larger size. Haha, analyze your needs first
OK~OVER~SHANGREN~

The above introduces some ideas for implementing unlimited classification in PHP. It also includes the content about being unable to access and you may not have permission to use network resources. I hope it will be helpful to friends who are interested in PHP tutorials. .