How to Flatten a Multidimensional Array?

 How to Flatten a Multidimensional Array?

    How to Flatten a Multidimensional Array?

    1. You can use the Standard PHP Library (SPL) to "hide" the recursion.

    <?php

        $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, " ";

        }

    ?>

    Out Put

    prints

    1 2 3 4 5 6 7 8 9 

   2.  As of PHP 5.3 the shortest solution seems to be 

        array_walk_recursive() with the new closures syntax:

        <?php

            function flatten(array $array) {

                $return = array();

                array_walk_recursive($array, function($a) 

                use (&$return) { $return[] = $a; });

                return $return;

            }

        ?>

    3. Solution for 2 dimensional array

        Please try this :

         <?php

            

            $array  = your array

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

            echo "<pre>";

            print_r($result);

        ?>

          Here is the solution which works for multi-dimensional array :

            <?php

                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);

            ?>  

    5.  In PHP 5.6 and above you can flatten two dimensional arrays 

        with array_merge after unpacking the outer array with .

        .. operator. The code is simple and clear.        

        <?

        array_merge(...$a);

        This works with collection of associative arrays too.

        

        $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

        )

        But it does not work when the outer array has non numeric keys.

         In that case, you will have to call array_values first.

        

        $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

        )

        ?>

    6. To flatten w/o recursion (as you have asked for),

         you can use a stack. Naturally you can put this into 

         a function of it's own like array_flatten. The following is a 

         version that works w/o keys:.      

        <?

         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;

            }

        ?>

        Notes:     

         Elements are processed in their order. Because subelements will be 

         moved on top of the stack, they will be processed next.

         

         It's possible to take keys into account as well, however, you'll

         need a different strategy to handle the stack. That's needed because

         you need to deal with possible duplicate keys in the sub-arrays.

    7.  Straightforward and One-liner answe

        <?php 

        function flatten_array(array $array)

            {

                return iterator_to_array(

                    new \RecursiveIteratorIterator(new \RecursiveArrayIterator($array)));

            }

            Usage:

            $array = [

                'name' => 'Allen Linatoc',

                'profile' => [

                    'age' => 21,

                    'favourite_games' => [ 'Call of Duty', 'Titanfall', 'Far Cry' ]

                ]

            ];

            print_r( flatten_array($array) );

            Output (in PsySH):

            Array

            (

                [name] => Allen Linatoc

                [age] => 21

                [0] => Call of Duty

                [1] => Titanfall

                [2] => Far Cry

            )

            Now it's pretty up to you now how you'll handle the keys.

        ?>  

    8. If you really don't like a recursion ... try shifting instead :)

        <?        

            $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];

                }

            }

        <?>    

            Note: In this simple version, this does not support array keys.