如何展平多维数组?


259

在PHP中是否可以在不使用递归或引用的情况下展平(二维/多维)数组?

我只关心的值,这样的键可以忽略不计,我想在的线array_map()array_values()


17
为什么要避免递归?
JorenB

5
欺骗

4
您不能对任意深度数组的所有元素进行递归操作(可以将其伪装为迭代,但是可以伪装成potato,potahto。)如果您只是想避免自己编写递归处理代码,请使用dk2.php.net/ manual / en / function.array-walk-recursive.php,带有将元素添加到可用数组的回调(使用global,userdata参数,将其全部放在类中并引用$ this等)
Michael Madsen

@JorenB:我想看到一个实现可以存档。
Alix Axel

看一下Nspl的flatten函数。您也可以用它指定深度。
Ihor Burlachenko '16

Answers:


276

您可以使用标准PHP库(SPL) “隐藏”递归。

$a = array(1,2,array(3,4, array(5,6,7), 8), 9);
$it = new RecursiveIteratorIterator(new RecursiveArrayIterator($a));
foreach($it as $v) {
  echo $v, " ";
}

版画

1 2 3 4 5 6 7 8 9 

351
我是唯一认为'RecursiveIteratorIterator'是一个愚蠢的名字的人吗?
nilamo

45
它比“吸引人的”更具“逻辑性”。并非所有事物都能像JOGL,Knol或Azure那样拥有出色的名称:-)
VolkerK,2009年

7
这对于作为孩子的空数组将不起作用。他们将作为父母返回。
hakre 2011年

45
iterator_to_array($it, false)避免了foreach的需要。
Alix Axel

3
在其他人介绍的内容的基础上,我能够创造出这个小帮手:function flatten($arr){ $it = new RecursiveIteratorIterator(new RecursiveArrayIterator($arr)); return iterator_to_array($it, true); }希望这对其他人有帮助。
Mike S.

295

PHP 5.3开始,最短的解决方案似乎是array_walk_recursive()使用新的闭合语法:

function flatten(array $array) {
    $return = array();
    array_walk_recursive($array, function($a) use (&$return) { $return[] = $a; });
    return $return;
}

33
如果需要键,则函数flatten(array $ array){$ return = array(); array_walk_recursive($ array,function($ a,$ b)use(&$ return){$ return [$ b] = $ a;}); 返回$ return; }
布伦登·凡·海森

您可以重写它以与php 5.2一起使用吗?
亚历克斯

2
@Alex不幸的是,您需要使用use语法来实现此功能,array_walk_recursive因为它不会接受$userdata引用的可选参数
Tim Seguine 2014年

1
看起来对这样的数组工作很好-> ideone.com/DsmApP但是对这样的数组不是很好-> ideone.com/5Kltva 还是我?
塞巴斯蒂安·皮斯科尔斯基

2
@Sebastian Piskorski这是因为您的值被视为键,因此,一旦在数组中引入自己的key => value对,您在第一个索引位置的数组值就会被视为没有值的键,并且因为键具有为唯一,两个键匹配,您的值将添加到同一键。一个简单的解决方案是首先对数组进行排序。这是PHP固有的行为。
马丁·舒特

92

二维阵列的解决方案

请尝试:

$array  = your array

$result = call_user_func_array('array_merge', $array);

echo "<pre>";
print_r($result);

编辑:13年8月21日

这是适用于多维数组的解决方案:

function array_flatten($array) {
    $return = array();
    foreach ($array as $key => $value) {
        if (is_array($value)){
            $return = array_merge($return, array_flatten($value));
        } else {
            $return[$key] = $value;
        }
    }

    return $return;
}

$array  = Your array

$result = array_flatten($array);

echo "<pre>";
print_r($result);

参考:http : //php.net/manual/en/function.call-user-func-array.php


谢谢,第一个在我从PDO获得的阵列上工作,而其他解决方案却没有。
2013年

7
这是一个糟糕的策略。call_user_func_array('array_merge', [])(注意,空数组)返回null并触发php警告错误。如果您知道数组不会为空的事实,这是一个明智的解决方案,但这并不是许多人可以做的常见假设。
山羊

OP特别要求非递归解决方案。
艾丽卡

哇,很酷的2D Flattern!但是为了防止通知,请使用$result = $array ?call_user_func_array('array_merge', $array) : [];
Alexander Goncharov

很酷的布鲁尔,但是您不是偶然得到了一个反函数数组降级了吗?
FantomX1

64

在PHP 5.6及更高版本中,您可以array_merge使用...运算符解压缩外部数组后,将二维数组展平。代码简单明了。

array_merge(...$a);

这也适用于关联数组的集合。

$a = [[10, 20], [30, 40]];
$b = [["x" => "X", "y" => "Y"], ["p" => "P", "q" => "Q"]];

print_r(array_merge(...$a));
print_r(array_merge(...$b));

Array
(
    [0] => 10
    [1] => 20
    [2] => 30
    [3] => 40
)
Array
(
    [x] => X
    [y] => Y
    [p] => P
    [q] => Q
)

但是当外部数组具有非数字键时,它将不起作用。在这种情况下,您将必须先致电array_values

$c = ["a" => ["x" => "X", "y" => "Y"], "b" => ["p" => "P", "q" => "Q"]];
print_r(array_merge(...array_values($c)));

Array
(
    [x] => X
    [y] => Y
    [p] => P
    [q] => Q
)

更新:基于@MohamedGharib的评论

如果外部数组为空,则将引发错误,因为array_merge将使用零参数进行调用。可以通过添加一个空数组作为第一个参数来避免这种情况。

array_merge([], ...$a);

1
仅当数组的每个元素都是数组时,此方法才有效。如果数组包含混合类型(例如标量),则将发生错误。
Otheus

@Otheus这是因为上述解决方案未使用递归。如您所说,它需要一个数组数组。但从好的方面来说,这应该比其他方法快得多,因为它没有函数调用的额外开销。
Joyce Babu

2
如果外部数组为空,则将引发错误;如果与外部数组组合,则可以避免array_merge([], ...$a);
Mohamed Gharib

@MohamedGharib不错。
Joyce Babu

如果使用关联数组可以通过这个解决方案stackoverflow.com/questions/40663687/...
亚历克斯

24

要展平递归(如您所愿),可以使用stack。自然地,您可以将其放入自己的like函数中array_flatten。以下是不带按键的版本:

function array_flatten(array $array)
{
    $flat = array(); // initialize return array
    $stack = array_values($array); // initialize stack
    while($stack) // process stack until done
    {
        $value = array_shift($stack);
        if (is_array($value)) // a value to further process
        {
            $stack = array_merge(array_values($value), $stack);
        }
        else // a value to take
        {
           $flat[] = $value;
        }
    }
    return $flat;
}

元素按其顺序处理。因为子元素将被移动到堆栈的顶部,所以接下来将对其进行处理。

也可以考虑密钥,但是,您将需要不同的策略来处理堆栈。这是必需的,因为您需要处理子数组中可能存在的重复键。相关问题中的类似答案: PHP在保留键的同时遍历多维数组

我不确定,但是II过去曾对此进行过测试:RecurisiveIterator确实使用了递归,所以这取决于您的实际需求。同样应该有可能基于堆栈创建递归迭代器:

foreach(new FlatRecursiveArrayIterator($array) as $key => $value)
{
    echo "** ($key) $value\n";
}

演示版

我到目前为止还没有实现RecursiveIterator我认为是个不错的主意的堆栈。


+1为出色的array_flatten函数。我必须if(!empty($value)){$flat[] = $value}在else语句中添加内容,以防止将空值添加到结果数组中。很棒的功能!
Alex Sarnowski

19

简单的一衬答案。

function flatten_array(array $array)
{
    return iterator_to_array(
         new \RecursiveIteratorIterator(new \RecursiveArrayIterator($array)));
}

用法:

$array = [
    'name' => 'Allen Linatoc',
    'profile' => [
        'age' => 21,
        'favourite_games' => [ 'Call of Duty', 'Titanfall', 'Far Cry' ]
    ]
];

print_r( flatten_array($array) );

输出(在PsySH中):

Array
(
    [name] => Allen Linatoc
    [age] => 21
    [0] => Call of Duty
    [1] => Titanfall
    [2] => Far Cry
)

现在由您自己决定如何处理密钥。干杯


编辑(2017-03-01)

引用奈杰尔·奥尔德顿的关注/问题:

为了澄清起见,这会保留键(甚至是数字键),因此丢失具有相同键的值。例如$array = ['a',['b','c']]变为Array ([0] => b, [1] => c )'a'之所以丢失,是因为'b'还有一个关键0

引用Svish的答案:

只需将false作为第二个参数添加($use_keys)iterator_to_array调用


需要澄清的是,这会保留键(甚至是数字键),因此丢失具有相同键的值。例如$array = ['a',['b','c']]变为Array ([0] => b, [1] => c )'a'之所以丢失,是因为'b'也有一个密钥0
Nigel Alderton

1
@NigelAlderton只需将false第二个参数($use_keys)添加到iterator_to_array调用中。
Svish

18

使用递归。希望一旦看到它不那么复杂,一旦看到它不那么复杂,对递归的恐惧就会消失。

function flatten($array) {
    if (!is_array($array)) {
        // nothing to do if it's not an array
        return array($array);
    }

    $result = array();
    foreach ($array as $value) {
        // explode the sub-array, and add the parts
        $result = array_merge($result, flatten($value));
    }

    return $result;
}


$arr = array('foo', array('nobody', 'expects', array('another', 'level'), 'the', 'Spanish', 'Inquisition'), 'bar');
echo '<ul>';
foreach (flatten($arr) as $value) {
    echo '<li>', $value, '</li>';
}
echo '<ul>';

输出:

<ul><li>foo</li><li>nobody</li><li>expects</li><li>another</li><li>level</li><li>the</li><li>Spanish</li><li>Inquisition</li><li>bar</li><ul>

1
我不担心递归,我只想学习其他方法来做到这一点。
Alix Axel

13
递归+1:希望看到递归的复杂程度后,一旦看到递归的复杂性,您对递归的恐惧就会消失。
Tiberiu-Ionuț Stan

1
好的,这已经结束了。如何有可能,即回复(“我不害怕递归”)是三个半大一岁(8月24日09)比初始声明(“......你递归的恐惧就会消失(... )“),是在13年2月5日制作的?
trejder 2013年

18

只是以为我会指出这是折叠,因此可以使用array_reduce:

array_reduce($my_array, 'array_merge', array());

编辑:请注意,这可以构成为平展任意数量的级别。我们可以通过几种方式做到这一点:

// Reduces one level
$concat   = function($x) { return array_reduce($x, 'array_merge', array()); };

// We can compose $concat with itself $n times, then apply it to $x
// This can overflow the stack for large $n
$compose  = function($f, $g) {
    return function($x) use ($f, $g) { return $f($g($x)); };
};
$identity = function($x) { return $x; };
$flattenA = function($n) use ($compose, $identity, $concat) {
    return  function($x) use ($compose, $identity, $concat, $n) {
        return ($n === 0)? $x
                         : call_user_func(array_reduce(array_fill(0, $n, $concat),
                                                       $compose,
                                                       $identity),
                                          $x);
    };
};

// We can iteratively apply $concat to $x, $n times
$uncurriedFlip     = function($f) {
    return  function($a, $b) use ($f) {
        return $f($b, $a);
    };
};
$iterate  = function($f) use ($uncurriedFlip) {
    return  function($n) use ($uncurriedFlip, $f) {
    return  function($x) use ($uncurriedFlip, $f, $n) {
        return ($n === 0)? $x
                         : array_reduce(array_fill(0, $n, $f),
                                        $uncurriedFlip('call_user_func'),
                                        $x);
    }; };
};
$flattenB = $iterate($concat);

// Example usage:
$apply    = function($f, $x) {
    return $f($x);
};
$curriedFlip = function($f) {
    return  function($a) use ($f) {
    return  function($b) use ($f, $a) {
        return $f($b, $a);
    }; };
};

var_dump(
    array_map(
        call_user_func($curriedFlip($apply),
                       array(array(array('A', 'B', 'C'),
                                   array('D')),
                             array(array(),
                                   array('E')))),
        array($flattenA(2), $flattenB(2))));

当然,我们也可以使用循环,但是这个问题要求使用array_map或array_values的组合函数。


多维!=二维。
Alix Axel

@atamur在PHP 5.3+上有效。如array_reduce的更改日志中所述,$ initial只能是5.3之前的整数,然后可以对其进行“混合”(即您的归约函数支持的任何内容)
Warbo

1
@AlixAxel您对的是多维的!=二维的,但是可以将其平坦化为任意数量的级别。构成折痕的一个很好的结果是,它遵守固定的限制。如果我有嵌套到5个级别的数组,则可以将fold其分为4个级别,或者fold . fold将其获取3个级别,或者fold . fold . fold将其获取2个级别,依此类推。例如。如果我想展平5D数组但得到4D数组,则该错误将立即触发。
华宝(Warbo)

我喜欢二维数组的解决方案。完全符合要求。
Tom Auger

我同意您的单级定义是最好的答案,它也非常简洁。但是我认为您命名错误$concat,我想您应该称呼它$flattenarray_merge是相当于concat的php。我试图得到array_concat添加为一个别名array_merge
icc97

9

仅展平二维数组:

$arr = [1, 2, [3, 4]];
$arr = array_reduce($arr, function ($a, $b) {
     return array_merge($a, (array) $b);
}, []);

// Result: [1, 2, 3, 4]

5

该解决方案是非递归的。请注意,元素的顺序会有所不同。

function flatten($array) {
    $return = array();
    while(count($array)) {
        $value = array_shift($array);
        if(is_array($value))
            foreach($value as $sub)
                $array[] = $sub;
        else
            $return[] = $value;
    }
    return $return;
}

1
聪明的主意,但是有一个错误。“ $ array [] = $ value”不会将$ value的所有元素都添加到$ array中,而只是添加$ value本身。如果运行此代码,它将无限期循环。
托德·欧文

是的,shifting数组中的值并再次将其附加到末尾没有多大意义。我想你想array_merge()代替吗?
deceze

4

我相信这是最干净的解决方案,无需使用任何突变或不熟悉的类。

<?php

function flatten($array)
{
    return array_reduce($array, function($acc, $item){
        return array_merge($acc, is_array($item) ? flatten($item) : [$item]);
    }, []);
}


// usage
$array = [1, 2, [3, 4], [5, [6, 7]], 8, 9, 10];
print_r(flatten($array));

3

尝试以下简单功能:

function _flatten_array($arr) {
  while ($arr) {
    list($key, $value) = each($arr); 
    is_array($value) ? $arr = $value : $out[$key] = $value;
    unset($arr[$key]);
  }
  return (array)$out;
}

所以从这个:

array (
  'und' => 
  array (
    'profiles' => 
    array (
      0 => 
      array (
        'commerce_customer_address' => 
        array (
          'und' => 
          array (
            0 => 
            array (
              'first_name' => 'First name',
              'last_name' => 'Last name',
              'thoroughfare' => 'Address 1',
              'premise' => 'Address 2',
              'locality' => 'Town/City',
              'administrative_area' => 'County',
              'postal_code' => 'Postcode',
            ),
          ),
        ),
      ),
    ),
  ),
)

你得到:

array (
  'first_name' => 'First name',
  'last_name' => 'Last name',
  'thoroughfare' => 'Address 1',
  'premise' => 'Address 2',
  'locality' => 'Town/City',
  'administrative_area' => 'County',
  'postal_code' => 'Postcode',
)

也许您应该检查一下功能...似乎没有预期的工作
Emiliano

@Emiliano尝试提出一个新问题,也许您的输入数据不同,所以在您的特定情况下将无法使用。
kenorb

我们有几个问题,每个问题都是不推荐使用的功能,您可以改善一点,因为您不是这里的新手,如果您的代码与特定版本的php一起使用,则应该知道第二点;如果不能与所有数据一起使用,请说第三点。
Emiliano

2

诀窍是通过引用传递源数组和目标数组。

function flatten_array(&$arr, &$dst) {
    if(!isset($dst) || !is_array($dst)) {
        $dst = array();
    }
    if(!is_array($arr)) {
        $dst[] = $arr;
    } else {
        foreach($arr as &$subject) {
            flatten_array($subject, $dst);
        }
    }
}

$recursive = array('1', array('2','3',array('4',array('5','6')),'7',array(array(array('8'),'9'),'10')));
echo "Recursive: \r\n";
print_r($recursive);
$flat = null;
flatten_array($recursive, $flat);

echo "Flat: \r\n";
print_r($flat);

// If you change line 3 to $dst[] = &$arr; , you won't waste memory,
// since all you're doing is copying references, and imploding the array 
// into a string will be both memory efficient and fast:)

echo "String:\r\n";
echo implode(',',$flat);

2
/**
 * For merging values of a multidimensional array into one 
 *
 * $array = [
 *     0 => [
 *         0 => 'a1',
 *         1 => 'b1',
 *         2 => 'c1',
 *         3 => 'd1'
 *     ],
 *     1 => [
 *         0 => 'a2',
 *         1 => 'b2',
 *         2 => 'c2',
 *     ]
 * ];
 *
 * becomes : 
 *
 * $array = [
 *     0 => 'a1',
 *     1 => 'b1',
 *     2 => 'c1',
 *     3 => 'd1',
 *     4 => 'a2',
 *     5 => 'b2',
 *     6 => 'c2',
 *     
 * ]
 */
array_reduce
(
    $multiArray
    , function ($lastItem, $currentItem) {
        $lastItem = $lastItem ?: array();
        return array_merge($lastItem, array_values($currentItem));
    }
);

要点代码段


这似乎仅支持二维数组。
Alix Axel

你是对的。没有意义使用它。我认为最好的解决方案是“ PHP过多”的答案。
阿萨姆(2013年


2

如果您真的不喜欢递归,请尝试转移:)

$a = array(1,2,array(3,4, array(5,6,7), 8), 9);
$o = [];
for ($i=0; $i<count($a); $i++) {
    if (is_array($a[$i])) {
        array_splice($a, $i+1, 0, $a[$i]);
    } else {
        $o[] = $a[$i];
    }
}

注意:在此简单版本中,它不支持数组键。


这是一个有趣的方法。与其他解决方案相比,它编辑原始数组($ a)。如果将其替换为continue,则速度会更快一些。
pcarvalho

2

如何使用递归生成器?https://ideone.com/d0TXCg

<?php

$array = [
    'name' => 'Allen Linatoc',
    'profile' => [
        'age' => 21,
        'favourite_games' => [ 'Call of Duty', 'Titanfall', 'Far Cry' ]
    ]
];

foreach (iterate($array) as $item) {
    var_dump($item);
};

function iterate($array)
{
    foreach ($array as $item) {
        if (is_array($item)) {
            yield from iterate($item);
        } else {
            yield $item;
        }
    }
}

1

对于PHP 5.2

function flatten(array $array) {
    $result = array();

    if (is_array($array)) {
        foreach ($array as $k => $v) {
            if (is_array($v)) {
                $result = array_merge($result, flatten($v));
            } else {
                $result[] = $v;
            }
        }
    }

    return $result;
}

请在此仅代码的答案中包含一些说明。
mickmackusa

1

此版本可以执行深,浅或特定数量的级别:

/**
 * @param  array|object $array  array of mixed values to flatten
 * @param  int|boolean  $level  0:deep, 1:shallow, 2:2 levels, 3...
 * @return array
 */
function flatten($array, $level = 0) {
    $level = (int) $level;
    $result = array();
    foreach ($array as $i => $v) {
        if (0 <= $level && is_array($v)) {
            $v = flatten($v, $level > 1 ? $level - 1 : 0 - $level);
            $result = array_merge($result, $v);
        } elseif (is_int($i)) {
            $result[] = $v;
        } else {
            $result[$i] = $v; 
        }
    }
    return $result;
}

除了说明此代码段可以做什么之外,请向未来的研究人员说明它的工作原理。
mickmackusa

1

因为这里的代码看起来很吓人。这是一个还将多维数组转换为html格式兼容语法的函数,但更易于阅读。

/**
 * Flattens a multi demensional array into a one dimensional
 * to be compatible with hidden html fields.
 *
 * @param array $array
 *  Array in the form:
 *  array(
 *    'a' => array(
 *      'b' => '1'
 *    )
 *  )
 *
 * @return array
 *  Array in the form:
 *  array(
 *    'a[b]' => 1,
 *  )
 */
function flatten_array($array) {
  // Continue until $array is a one-dimensional array.
  $continue = TRUE;
  while ($continue) {
    $continue = FALSE;

    // Walk through top and second level of $array and move 
    // all values in the second level up one level.
    foreach ($array as $key => $value) {
      if (is_array($value)) {
        // Second level found, therefore continue.
        $continue = TRUE;

        // Move each value a level up.
        foreach ($value as $child_key => $child_value) {
          $array[$key . '[' . $child_key . ']'] = $child_value;
        }

        // Remove second level array from top level.
        unset($array[$key]);
      }
    }
  }

  return $array;
}


0

这是我的解决方案,使用参考:

function arrayFlatten($array_in, &$array_out){

    if(is_array($array_in)){
        foreach ($array_in as $element){
               arrayFlatten($element, $array_out);
        }
    }
    else{
        $array_out[] = $array_in; 
    }
}

$arr1 = array('1', '2', array(array(array('3'), '4', '5')), array(array('6')));

arrayFlatten($arr1, $arr2);

echo "<pre>";
print_r($arr2);
echo "</pre>";

请提供一些有关您的代码片段如何工作以及为什么这样的主意的解释。纯代码的答案在StackOverflow上价值不高,因为它们在教育OP和未来研究人员的能力方面做得很差。记住,我们绝不向OP讲话;旧页面用于关闭新页面,因此页面还需要足够的信息以解决将来的提问者的问题。
mickmackusa

0
<?php
//recursive solution

//test array
$nested_array = [[1,2,[3]],4,[5],[[[6,[7=>[7,8,9,10]]]]]];

/*-----------------------------------------
function call and return result to an array
------------------------------------------*/
$index_count = 1;
$flatered_array = array();
$flatered_array = flat_array($nested_array, $index_count);

/*-----------------------------------------
Print Result
-----------------------------------------*/
echo "<pre>";
print_r($flatered_array);


/*-----------------------------------------
function to flaten an array 
-----------------------------------------*/
function flat_array($nested_array, & $index_count, & $flatered_array) {

  foreach($nested_array AS $key=>$val) {
      if(is_array($val)) {
        flat_array($val, $index_count, $flatered_array);
      }
      else {
        $flatered_array[$index_count] = $val;
        ++$index_count;
      }      
  }

return $flatered_array;
}
?>

0

这是一个简单的方法:

$My_Array = array(1,2,array(3,4, array(5,6,7), 8), 9);

function checkArray($value) {
    foreach ($value as $var) {
        if ( is_array($var) ) {
            checkArray($var);
        } else {
            echo $var;
        }
    }
}

checkArray($My_Array);

0

任何人正在寻找一个真正干净的解决方案;这是一个选择:

$test_array = array(
    array('test' => 0, 0, 0, 0),
    array(0, 0, 'merp' => array('herp' => 'derp'), 0),
    array(0, 0, 0, 0),
    array(0, 0, 0, 0)
);
$it = new RecursiveIteratorIterator(new RecursiveArrayIterator($test_array));
var_dump( iterator_to_array($it, false) ) ; 

版画

 0 0 0 0 0 0 derp 0 0 0 0 0 0 0 0 0

0

只是发布其他解决方案)

function flatMultidimensionalArray(array &$_arr): array
{
    $result = [];
    \array_walk_recursive($_arr, static function (&$value, &$key) use (&$result) {
        $result[$key] = $value;
    });

    return $result;
}

0

如果您还想保留自己的钥匙,那就是解决方案。

function reduce(array $array) {
    $return = array();
    array_walk_recursive($array, function($value, $key) use (&$return) { $return[$key] = $value; });
    return $return;
}

不幸的是,它仅输出最终的嵌套数组,而没有中间键。因此,对于以下示例:

$array = array(
    'sweet' => array(
        'a' => 'apple',
        'b' => 'banana'),
    'sour' => 'lemon'); 
print_r(flatten($fruits));

输出为:

Array
(
    [a] => apple
    [b] => banana
    [sour] => lemon
)

-1

我需要以HTML输入格式表示PHP多维数组。

$test = [
    'a' => [
        'b' => [
            'c' => ['a', 'b']
        ]
    ],
    'b' => 'c',
    'c' => [
        'd' => 'e'
    ]
];

$flatten = function ($input, $parent = []) use (&$flatten) {
    $return = [];

    foreach ($input as $k => $v) {
        if (is_array($v)) {
            $return = array_merge($return, $flatten($v, array_merge($parent, [$k])));
        } else {
            if ($parent) {
                $key = implode('][', $parent) . '][' . $k . ']';

                if (substr_count($key, ']') != substr_count($key, '[')) {
                    $key = preg_replace('/\]/', '', $key, 1);
                }
            } else {
                $key = $k;
            }           

            $return[$key] = $v;
        }
    }

    return $return;
};

die(var_dump( $flatten($test) ));

array(4) {
  ["a[b][c][0]"]=>
  string(1) "a"
  ["a[b][c][1]"]=>
  string(1) "b"
  ["b"]=>
  string(1) "c"
  ["c[d]"]=>
  string(1) "e"
}


@AlixAxel这个评论是相对的吗?错误的帖子..?
Gajus 2013年

否。我认为这与您的工作非常相似,因此决定共享它,我认为唯一的区别是我的表示形式也是有效的PHP $var['a']['b']['c'][0] = 'a'; ...
Alix Axel 2013年

我故意需要HTML输出。虽然谢谢您的分享。
Gajus 2013年

1
我认为这是对错误问题的正确答案。回答时,请尝试回答所提出的问题-否则页面可能会偏离核心问题,并使未来的研究人员感到困惑。
mickmackusa

-1

如果您有一个对象数组并想用一个节点将其展平,则只需使用以下函数:

function objectArray_flatten($array,$childField) {
    $result = array();
    foreach ($array as $node)
    {
        $result[] = $node;
        if(isset($node->$childField))
        {
            $result = array_merge(
                $result, 
                objectArray_flatten($node->$childField,$childField)
            );
            unset($node->$childField);
        }

    }
    return $result;
}
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.