Преобразование многомерного массива в один массив

У меня есть массив, который многомерен без причины

/* This is how my array is currently */
Array
(
[0] => Array
    (
        [0] => Array
            (
                [plan] => basic
            )

        [1] => Array
            (
                [plan] => small
            )

        [2] => Array
            (
                [plan] => novice
            )

        [3] => Array
            (
                [plan] => professional
            )

        [4] => Array
            (
                [plan] => master
            )

        [5] => Array
            (
                [plan] => promo
            )

        [6] => Array
            (
                [plan] => newplan
            )

    )

 )

Я хочу преобразовать этот массив в эту форму

/*Now, I want to simply it down to this*/
Array (
[0] => basic
[1] => small
[2] => novice
[3] => professional
[4] => master
[5] => promo
[6] => newplan
)

Есть идеи, как это сделать?

Ответы

Ответ 1

Предполагая, что этот массив может быть или не быть избыточно вложенным, и вы не уверены в его глубине, это должно сгладить его для вас:

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

Ответ 2

$array = array_column($array, 'plan');

Первый аргумент - это массив | Второй аргумент - это ключ массива.

Примечание: array_column был введен в PHP 5.5, поэтому он не будет работать в более ранних версиях.

Ответ 3

Просто назначьте ему свой собственный первый элемент:

$array = $array[0];

Ответ 4

 $singleArray = array();

    foreach ($multiDimensionalArray as $key => $value){
        $singleArray[$key] = $value['plan'];
    }

это лучший способ создать массив из массива multiDimensionalArray.

спасибо

Ответ 5

Если вы столкнетесь с многомерным массивом, который представляет собой чистые данные, как показано ниже, вы можете использовать один вызов array_merge() для выполнения работы с помощью отражения:

$arrayMult = [ ['a','b'] , ['c', 'd'] ];
$arraySingle = call_user_func_array('array_merge', $arrayMult);
// $arraySingle is now = ['a','b', 'c', 'd'];

Ответ 6

В этом конкретном случае это будет делать:

$array = array_map('current', $array[0]);

В основном, тот же самый вопрос, этот вопрос, посмотрите на некоторые ответы там: Слияние PHP-массива с неизвестным количеством параметров.

Ответ 7

Вы можете сделать это, просто используя цикл.

    $singleArray = array();

    foreach ($multiDimensionalArray as $key => $value){
        $singleArray[$key] = $value['plan'];
    }

Ответ 8

Недавно я использовал функцию AlienWebguy array_flatten, но это дало мне проблему, из-за которой было очень сложно найти причину. array_merge вызывает проблемы, и это уже не первый случай, когда у меня возникли проблемы с этим.
Если у вас есть одни и те же ключи массива в одном внутреннем массиве, которые вы делаете в другом, то более поздние значения будут перезаписывать предыдущие в объединенном массиве.

Здесь другая версия array_flatten без использования array_merge:

function array_flatten($array) { 
  if (!is_array($array)) { 
    return FALSE; 
  } 
  $result = array(); 
  foreach ($array as $key => $value) { 
    if (is_array($value)) { 
      $arrayList=array_flatten($value);
      foreach ($arrayList as $listItem) {
        $result[] = $listItem; 
      }
    } 
   else { 
    $result[$key] = $value; 
   } 
  } 
  return $result; 
}

Ответ 9

Ваш образец массива имеет 3 уровня. Поскольку первый уровень имеет только [0], вы можете жестко закодировать свой доступ к нему и избежать дополнительного вызова функции/конструкции.

(Код Демо)

array_walk_recursive() удобна и универсальна, но для этой задачи может быть излишним и, конечно, немного более запутанным с точки зрения читабельности.
```
array_walk_recursive($array, function($leafvalue)use(&$flat){$flat[] = $leafvalue;});
var_export($flat);
```
Если бы это был мой код, я бы использовал array_column(), потому что он прямой и говорит буквально о выполняемом действии.
```
var_export(array_column($array[0], 'plan'));
```
Конечно, пара циклов 'foreach() будет работать очень эффективно, потому что языковые конструкции обычно работают более эффективно, чем вызовы функций.
```
foreach ($array[0] as $plans) {
    foreach ($plans as $value) {
        $flat[] = $value;
    }
}
var_export($flat);
```
Наконец, в качестве шутливой альтернативы (которую я не могу себе представить, фактически использующей, если я не писал код для кого-то, о ком я не заботился), я предложу вызов array_merge_recursive() с оператором splat (...),
```
var_export(array_merge_recursive(...$array[0])['plan']);
```

Ответ 10

Несмотря на то, что array_column будет хорошо работать здесь, в случае, если вам нужно сгладить любой массив независимо от его внутренней структуры, вы можете использовать эту библиотеку массивов для достижения этого без труда:

$flattened = Arr::flatten($array);

который будет производить именно тот массив, который вы хотите.

Ответ 11

Я сделал это с стилем ООП

$res=[1=>[2,3,7,8,19],3=>[4,12],2=>[5,9],5=>6,7=>[10,13],10=>[11,18],8=>[14,20],12=>15,6=>[16,17]];
class MultiToSingle{
public $result=[];
public function __construct($array){
    if(!is_array($array)){
        echo "Give a array";
    }
    foreach($array as $key => $value){
        if(is_array($value)){
            for($i=0;$i<count($value);$i++){
                $this->result[]=$value[$i];
            }  
        }else{
            $this->result[]=$value;
        }
    }
}
}

$obj= new MultiToSingle($res);
$array=$obj->result;
print_r($array);

Ответ 12

Многомерный массив для одиночного массива с одним строковым кодом!!! Наслаждайтесь кодом.

$array=[1=>[2,5=>[4,2],[7,8=>[3,6]],5],4];
$arr=[];
array_walk_recursive($array, function($k){global $arr; $arr[]=$k;});
print_r($arr);

... Наслаждайтесь кодом.

Ответ 13

Следуя этой схеме

$input = array(10, 20, array(30, 40), array('key1' => '50', 'key2'=>array(60), 70));

Вызовите функцию:

echo "<pre>";print_r(flatten_array($input, $output=null));

Объявление функции:

function flatten_array($input, $output=null) {
if($input == null) return null;
if($output == null) $output = array();
foreach($input as $value) {
    if(is_array($value)) {
        $output = flatten_array($value, $output);
    } else {
        array_push($output, $value);
    }
}
return $output;

}

Ответ 14

Я написал дополнение к принятому ответу. Если кому-то, как и мне, нужна префиксная версия ключей, это может быть полезно.

Array
(
    [root] => Array
        (
            [url] => http://localhost/misc/markia
        )

)

Array
(
    [root.url] => http://localhost/misc/markia
)

<?php
function flattenOptions($array, $old = '') {
  if (!is_array($array)) {
    return FALSE;
  }
  $result = array();
  foreach ($array as $key => $value) {
    if (is_array($value)) {
      $result = array_merge($result, flattenOptions($value, $key));
    }
    else {
      $result[$old . '.' . $key] = $value;
    }
  }
  return $result;
}

Ответ 15

ни один из ответов не помог мне, если у меня было несколько уровней вложенных массивов. решение почти такое же, как у @AlienWebguy, но с небольшой разницей.

function nestedToSingle(array $array)
{
    $singleDimArray = [];

    foreach ($array as $item) {

        if (is_array($item)) {
            $singleDimArray = array_merge($singleDimArray, nestedToSingle($item));

        } else {
            $singleDimArray[] = $item;
        }
    }

    return $singleDimArray;
}

тестовый пример

$array = [
        'first',
        'second',
        [
            'third',
            'fourth',
        ],
        'fifth',
        [
            'sixth',
            [
                'seventh',
                'eighth',
                [
                    'ninth',
                    [
                        [
                            'tenth'
                        ]
                    ]
                ],
                'eleventh'
            ]
        ],
        'twelfth'
    ];

    $array = nestedToSingle($array);
    print_r($array);

    //output
    array:12 [
        0 => "first"
        1 => "second"
        2 => "third"
        3 => "fourth"
        4 => "fifth"
        5 => "sixth"
        6 => "seventh"
        7 => "eighth"
        8 => "ninth"
        9 => "tenth"
        10 => "eleventh"
        11 => "twelfth"
   ]

Ответ 16

$flattenArray = [];

foreach ($parentArray as $childArray) {
    foreach ($childArray as $value) {
        $flattenArray[] = $value;
    }
}

Ответ 17

Попробуйте это, это работает для меня:

    $newArray = array();
            foreach($operator_call_logs as $array) {
                foreach($array as $k=>$v) {
                    $newArray[$k] = $v;
                }
            }

Ответ 18

Сохраните это как файл php, просто импортируйте и используйте функцию single_array()

<?php
$GLOBALS['single_array']=[];
function array_conveter($array_list){
    if(is_array($array_list)){
        foreach($array_list as $array_ele){
            if(is_array($array_ele)){
                array_conveter($array_ele);
            }else{
                array_push($GLOBALS['single_array'],$array_ele);
            }
        }
    }else{
        array_push($GLOBALS['single_array'],$array_list);
    }
}
function single_array($mix){
    foreach($mix as $single){
        array_conveter($single);
    }return $GLOBALS['single_array'];
    $GLOBALS['single_array']=[];
}
/* Example convert your multi array to single  */
$mix_array=[3,4,5,[4,6,6,7],'abc'];
print_r(single_array($mix_array));

?>