有没有办法找出来有多"深"a PHP array是什么?
-
06-07-2019 - |
题
PHP阵列可以有阵列,用于它的元素。和那些阵列可以有阵列等等。有没有一种方法,以找出最大的筑巢,存在一个PHP array?一个例子将是一个函数,返回1如果最初的阵没有阵列因素,2如果至少一个元件阵列,等等。
解决方案
这应该这样做:
<?php
function array_depth(array $array) {
$max_depth = 1;
foreach ($array as $value) {
if (is_array($value)) {
$depth = array_depth($value) + 1;
if ($depth > $max_depth) {
$max_depth = $depth;
}
}
}
return $max_depth;
}
?>
编辑:非常快速地测试它,它似乎工作。
其他提示
这是另一种避免Kent Fredric指出的问题的替代方案。它为 print_r()提供了检查无限递归(它做得好)的任务,并在输出中使用缩进找到阵列的深度。
function array_depth($array) {
$max_indentation = 1;
$array_str = print_r($array, true);
$lines = explode("\n", $array_str);
foreach ($lines as $line) {
$indentation = (strlen($line) - strlen(ltrim($line))) / 4;
if ($indentation > $max_indentation) {
$max_indentation = $indentation;
}
}
return ceil(($max_indentation - 1) / 2) + 1;
}
当心 的例子,仅仅这样做。
Php可以创建数组提到其他地方在这一阵列,并且可以包含对象有同样递引用,和任何纯粹的递归算法可能被认为是在这样的情况下一个 危险 天真之一,在于它将溢出叠深入递归访问,并且永远不会终止。
(嗯,它将终止当超过堆深度,并在这一点你的计划将是致命的终止,不是什么我觉得你想要的)
在过去,我曾试图serialise->替换参照标记的字符串->deserialise我的需要,(往往是调试跟踪与负荷递归的参考文献在他们的),这似乎是工作的好的,你得到的孔无处不在,但它适用于这项任务。
对于你的任务,如果你找到你的阵/结构已递引用突然出现在这,你可能想看看用户贡献的意见: http://php.net/manual/en/language.references.spot.php
然后以某种方式找到一种方法来最深入的递归的路径。
你可能需要拿出你的CS书algorhthms和打击这些婴儿:
(抱歉这么简短,但深入研究图论的是多一点适用于这种格式;))
嗨这是另一种解决方案。
/*** IN mixed (any value),OUT (string)maxDepth ***/
/*** Retorna la profundidad maxima de un array ***/
function getArrayMaxDepth($input){
if( ! canVarLoop($input) ) { return "0"; }
$arrayiter = new RecursiveArrayIterator($input);
$iteriter = new RecursiveIteratorIterator($arrayiter);
foreach ($iteriter as $value) {
//getDepth() start is 0, I use 0 for not iterable values
$d = $iteriter->getDepth() + 1;
$result[] = "$d";
}
return max( $result );
}
/*** IN mixed (any value),OUT (bool)true/false, CHECK if can be used by foreach ***/
/*** Revisa si puede ser iterado con foreach ***/
function canVarLoop($input) {
return (is_array($input) || $input instanceof Traversable) ? true : false;
}
在这里获得一些灵感后,在找到这个 之后我在PHP文档中发现了RecursiveIteratorIterator ,我来到了这个解决方案。
你应该使用这个,非常整洁:
function getArrayDepth($array) {
$depth = 0;
$iteIte = new RecursiveIteratorIterator(new RecursiveArrayIterator($array));
foreach ($iteIte as $ite) {
$d = $iteIte->getDepth();
$depth = $d > $depth ? $d : $depth;
}
return $depth;
}
适用于PHP5和PHP7,希望这会有所帮助。
当我注意到这篇文章时,我刚刚找到了这个问题的答案。这是我的解决方案。我没有在很多不同的阵列尺寸上尝试过这个,但是对于我使用的数据来说,它比2008年的答案快了~30个深度&gt; 4.
function deepness(array $arr){
$exploded = explode(',', json_encode($arr, JSON_FORCE_OBJECT)."\n\n");
$longest = 0;
foreach($exploded as $row){
$longest = (substr_count($row, ':')>$longest)?
substr_count($row, ':'):$longest;
}
return $longest;
}
警告:这不会处理任何边缘情况。如果您需要在其他地方寻找一个强大的解决方案,但对于简单的情况,我发现它非常快。
Jeremy Ruten对该功能的另一个(更好的)修改:
function array_depth($array, $childrenkey = "_no_children_")
{
if (!empty($array[$childrenkey]))
{
$array = $array[$childrenkey];
}
$max_depth = 1;
foreach ($array as $value)
{
if (is_array($value))
{
$depth = array_depth($value, $childrenkey) + 1;
if ($depth > $max_depth)
{
$max_depth = $depth;
}
}
}
return $max_depth;
}
将默认值添加到 $ childrenkey 允许该函数适用于没有子元素键的简单数组,即它适用于简单的多维数组。
现在可以使用以下方法调用此函数:
$my_array_depth = array_depth($my_array, 'the_key_name_storing_child_elements');
或
$my_array_depth = array_depth($my_array);
当 $ my_array 没有任何特定的密钥来存储其子元素时。
这是我对jeremy Ruten功能的略微修改版本
// you never know if a future version of PHP will have this in core
if (!function_exists('array_depth')) {
function array_depth($array) {
// some functions that usually return an array occasionally return false
if (!is_array($array)) {
return 0;
}
$max_indentation = 1;
// PHP_EOL in case we're running on Windows
$lines = explode(PHP_EOL, print_r($array, true));
foreach ($lines as $line) {
$indentation = (strlen($line) - strlen(ltrim($line))) / 4;
$max_indentation = max($max_indentation, $indentation);
}
return ceil(($max_indentation - 1) / 2) + 1;
}
}
print array_depth($ GLOBALS)
之类的内容不会因递归而出错,但您可能无法获得预期的结果。
function createDeepArray(){
static $depth;
$depth++;
$a = array();
if($depth <= 10000){
$a[] = createDeepArray();
}
return $a;
}
$deepArray = createDeepArray();
function deepness(array $arr){
$exploded = explode(',', json_encode($arr, JSON_FORCE_OBJECT)."\n\n");
$longest = 0;
foreach($exploded as $row){
$longest = (substr_count($row, ':')>$longest)?
substr_count($row, ':'):$longest;
}
return $longest;
}
function array_depth($arr)
{
if (!is_array($arr)) { return 0; }
$arr = json_encode($arr);
$varsum = 0; $depth = 0;
for ($i=0;$i<strlen($arr);$i++)
{
$varsum += intval($arr[$i] == '[') - intval($arr[$i] == ']');
if ($varsum > $depth) { $depth = $varsum; }
}
return $depth;
}
echo 'deepness():', "\n";
$start_time = microtime(TRUE);
$start_memory = memory_get_usage();
var_dump(deepness($deepArray));
$end_time = microtime(TRUE);
$end_memory = memory_get_usage();
echo 'Memory: ', ($end_memory - $start_memory), "\n";
echo 'Time: ', ($end_time - $start_time), "\n";
echo "\n";
echo 'array_depth():', "\n";
$start_time = microtime(TRUE);
$start_memory = memory_get_usage();
var_dump(array_depth($deepArray));
$end_time = microtime(TRUE);
$end_memory = memory_get_usage();
echo 'Memory: ', ($end_memory - $start_memory), "\n";
echo 'Time: ', ($end_time - $start_time), "\n";
Josh提出的功能肯定更快:
$ for i in `seq 1 10`; do php test.php; echo '-------------------------';done
deepness():
int(10000)
Memory: 164
Time: 0.0079939365386963
array_depth():
int(10001)
Memory: 0
Time: 0.043087005615234
-------------------------
deepness():
int(10000)
Memory: 164
Time: 0.0076408386230469
array_depth():
int(10001)
Memory: 0
Time: 0.042832851409912
-------------------------
deepness():
int(10000)
Memory: 164
Time: 0.0080249309539795
array_depth():
int(10001)
Memory: 0
Time: 0.042320966720581
-------------------------
deepness():
int(10000)
Memory: 164
Time: 0.0076301097869873
array_depth():
int(10001)
Memory: 0
Time: 0.041887998580933
-------------------------
deepness():
int(10000)
Memory: 164
Time: 0.0079131126403809
array_depth():
int(10001)
Memory: 0
Time: 0.04217004776001
-------------------------
deepness():
int(10000)
Memory: 164
Time: 0.0078539848327637
array_depth():
int(10001)
Memory: 0
Time: 0.04179310798645
-------------------------
deepness():
int(10000)
Memory: 164
Time: 0.0080208778381348
array_depth():
int(10001)
Memory: 0
Time: 0.04272198677063
-------------------------
deepness():
int(10000)
Memory: 164
Time: 0.0077919960021973
array_depth():
int(10001)
Memory: 0
Time: 0.041619062423706
-------------------------
deepness():
int(10000)
Memory: 164
Time: 0.0080950260162354
array_depth():
int(10001)
Memory: 0
Time: 0.042663097381592
-------------------------
deepness():
int(10000)
Memory: 164
Time: 0.0076849460601807
array_depth():
int(10001)
Memory: 0
Time: 0.042278051376343
一个老问题,但仍与此日期相关。 :)
不妨对Jeremy Ruten的回答做一点修改。
function array_depth($array, $childrenkey)
{
$max_depth = 1;
if (!empty($array[$childrenkey]))
{
foreach ($array[$childrenkey] as $value)
{
if (is_array($value))
{
$depth = array_depth($value, $childrenkey) + 1;
if ($depth > $max_depth)
{
$max_depth = $depth;
}
}
}
}
return $max_depth;
}
我添加了第二个名为 $ childrenkey 的参数,因为我将子元素存储在特定的键中。
函数调用的一个例子是:
$my_array_depth = array_depth($my_array, 'the_key_name_storing_child_elements');
我认为没有内置任何东西。虽然简单的递归函数很容易找到。
// very simple and clean approach
function array_depth($a) {
static $depth = 0;
if(!is_array($a)) {
return $depth;
}else{
$depth++;
array_map("array_depth", $a);
return $depth;
}
}
print "depth:" . array_depth(array('k9' => 'dog')); // return 1
我认为Kent Frederic强调的问题至关重要。 yjerem和Asim建议的答案容易受到这个问题的影响。
yjerem再次建议缩进的方法,dave1010对我来说不够稳定,因为它依赖于用print_r函数表示缩进的空格数。它可能随时间/服务器/平台而变化。
JoshN提出的方法可能是正确的,但我认为我的更快:
function array_depth($arr)
{
if (!is_array($arr)) { return 0; }
$arr = json_encode($arr);
$varsum = 0; $depth = 0;
for ($i=0;$i<strlen($arr);$i++)
{
$varsum += intval($arr[$i] == '[') - intval($arr[$i] == ']');
if ($varsum > $depth) { $depth = $varsum; }
}
return $depth;
}
如果您进行任何比较不同方法的测试,请发布消息。 Ĵ
我相信您忘记过滤'['和']'或','和':'以及数组键和值的数据类型。这是你的array_depth的更新加上一个额外的array_sort_by_depth。
function array_depth($arr){
if (is_array($arr)) {
array_walk($arr,
function($val, $key) use(&$arr) {
if ((! is_string($val)) && (! is_array($val))) {
$val = json_encode($val, JSON_FORCE_OBJECT);
}
if (is_string($val)) {
$arr[$key] = preg_replace('/[:,]+/', '', $val);
}
}
);
$json_strings = explode(',', json_encode($arr, JSON_FORCE_OBJECT));
$max_depth = 0;
foreach ($json_strings as $json_string){
var_dump($json_string); echo "<br/>";
$json_string = preg_replace('/[^:]{1}/', '', $json_string);
var_dump($json_string); echo "<br/><br/>";
$depth = strlen($json_string);
if ($depth > $max_depth) {
$max_depth = $depth;
}
}
return $max_depth;
}
return FALSE;
}
function array_sort_by_depth(&$arr_val, $reverse = FALSE) {
if ( is_array($arr_val)) {
$temp_arr = array();
$result_arr = array();
foreach ($arr_val as $key => $val) {
$temp_arr[$key] = array_depth($val);
}
if (is_bool($reverse) && $reverse == TRUE) {
arsort($temp_arr);
}
else {
asort($temp_arr);
}
foreach ($temp_arr as $key => $val) {
$result_arr[$key] = $arr_val[$key];
}
$arr_val = $result_arr;
return TRUE;
}
return FALSE;
}
随意改进代码:D!
我认为这样可以解决递归问题,而且还可以在不依赖其他php函数(如serialize或print_r)的情况下提供深度(这样做最有风险并且可能导致棘手的错误):
function array_depth(&$array) {
$max_depth = 1;
$array['__compute_array_depth_flag_ZXCNADJHHDKAQP'] = 1;
foreach ($array as $value) {
if (is_array($value) &&
!isset($value['__compute_array_depth_flag_ZXCNADJHHDKAQP'])) {
$depth = array_depth($value) + 1;
if ($depth > $max_depth) {
$max_depth = $depth;
}
}
}
unset($array['__compute_array_depth_flag_ZXCNADJHHDKAQP']);
return $max_depth;
}
这个似乎对我很好
<?php
function array_depth(array $array)
{
$depth = 1;
foreach ($array as $value) {
if (is_array($value)) {
$depth += array_depth($value);
break;
}
}
return $depth;
}
我会使用以下代码:
function maxDepth($array) {
$iterator = new \RecursiveIteratorIterator(new \RecursiveArrayIterator($array), \RecursiveIteratorIterator::CHILD_FIRST);
$iterator->rewind();
$maxDepth = 0;
foreach ($iterator as $k => $v) {
$depth = $iterator->getDepth();
if ($depth > $maxDepth) {
$maxDepth = $depth;
}
}
return $maxDepth;
}
更快捷的方式:
max(array_map('count', $array));