Как "сгладить" многомерный массив до простого в PHP?

Это, вероятно, вопрос новичка, но я уже давно просматриваю документацию, и я не могу найти никакого решения. Я думал, что могу использовать implode для каждого измерения, а затем вернуть эти строки вместе с str_split чтобы создать новый простой массив. Однако я никогда не знаю, если шаблон соединения не находится также в значениях и поэтому после выполнения str_split мои исходные значения могут сломаться.



есть что-то вроде combine($array1, $array2) для массивов внутри многомерного массива?

1398   19  

19 ответов:

использовать array_walk_recursive

<?php

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

$objTmp = (object) array('aFlat' => array());

array_walk_recursive($aNonFlat, create_function('&$v, $k, &$t', '$t->aFlat[] = $v;'), $objTmp);

var_dump($objTmp->aFlat);

/*
array(11) {
  [0]=>
  int(1)
  [1]=>
  int(2)
  [2]=>
  int(3)
  [3]=>
  int(4)
  [4]=>
  int(5)
  [5]=>
  int(6)
  [6]=>
  int(7)
  [7]=>
  int(8)
  [8]=>
  int(9)
  [9]=>
  int(10)
  [10]=>
  int(11)
}
*/

?>

протестировано с PHP 5.5.9-1ubuntu4. 24 (cli) (встроенный: Mar 16 2018 12:32:06)

41  
2018-05-03 05:22:33 
$array  = your array

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

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

REF:http://php.net/manual/en/function.call-user-func-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);
110  
2017-02-17 12:24:48

Это одна линия, супер проста в использовании:

$result = array();
array_walk_recursive($original_array,function($v) use (&$result){ $result[] = $v; });

Это очень легко понять, внутри анонимной функции/закрытия. $v ценность $original_array.

40  
2018-07-16 04:07:10 
// $array = your multidimensional array

$flat_array = array();

foreach(new RecursiveIteratorIterator(new RecursiveArrayIterator($array)) as $k=>$v){

$flat_array[$k] = $v;

}

также документально: http://www.phpro.org/examples/Flatten-Array.html

18  
2011-08-30 07:16:50 
function flatten_array($array, $preserve_keys = 0, &$out = array()) {
    # Flatten a multidimensional array to one dimension, optionally preserving keys.
    #
    # $array - the array to flatten
    # $preserve_keys - 0 (default) to not preserve keys, 1 to preserve string keys only, 2 to preserve all keys
    # $out - internal use argument for recursion
    foreach($array as $key => $child)
        if(is_array($child))
            $out = flatten_array($child, $preserve_keys, $out);
        elseif($preserve_keys + is_string($key) > 1)
            $out[$key] = $child;
        else
            $out[] = $child;
    return $out;
}
5  
2009-02-09 01:16:22

другой метод из PHP комментарии пользователей (упрощенный) и здесь:

function array_flatten_recursive($array) { 
   if (!$array) return false;
   $flat = array();
   $RII = new RecursiveIteratorIterator(new RecursiveArrayIterator($array));
   foreach ($RII as $value) $flat[] = $value;
   return $flat;
}

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

$array = array( 
    'A' => array('B' => array( 1, 2, 3)), 
    'C' => array(4, 5) 
); 
print_r(array_flatten_recursive($array)); 

#Returns: 
Array ( 
    [0] => 1 
    [1] => 2 
    [2] => 3 
    [3] => 4 
    [4] => 5 
)
5  
2011-06-13 12:04:45

нерекурсивное решение (но разрушающее порядок):

function flatten($ar) {
    $toflat = array($ar);
    $res = array();

    while (($r = array_shift($toflat)) !== NULL) {
        foreach ($r as $v) {
            if (is_array($v)) {
                $toflat[] = $v;
            } else {
                $res[] = $v;
            }
        }
    }

    return $res;
}
4  
2009-02-09 00:56:36

в PHP>=5.3 и на основе ответа Люка М (Первый) вы можете использовать замыкания, как это

array_walk_recursive($aNonFlat, function(&$v, $k, &$t){$t->aFlat[] = $v;}, $objTmp);

мне это нравится, потому что мне не нужно окружать код функции кавычками, как при использовании create_function()

4  
2011-08-25 01:58:29

С PHP 7, Вы можете использовать генераторы и делегирование генератора (yield from), чтобы выровнять массив:

function array_flatten_iterator (array $array) {
    foreach ($array as $value) {
        if (is_array($value)) {
            yield from array_flatten_iterator($value);
        } else {
            yield $value;
        }
    }
}

function array_flatten (array $array) {
    return iterator_to_array(array_flatten_iterator($array), false);
}

пример:

$array = [
    1,
    2,
    [
        3,
        4,
        5,
        [
            6,
            7
        ],
        8,
        9,
    ],
    10,
    11,
];    

var_dump(array_flatten($array));

http://3v4l.org/RU30W

3  
2015-06-29 18:12:22

использование функций более высокого порядка (примечание: Я использую анонимные функции как inline, который появился в PHP 5.3):

function array_flatten($array) {
    return array_reduce(
        $array,
        function($prev, $element) {
            if (!is_array($element))
                $prev[] = $element;
            else
                $prev = array_merge($prev, array_flatten($element));
            return $prev;
        },
        array()
    );
}
2  
2016-05-10 21:43:16

новый подход, основанный на предыдущем примере функции, представленной chaos, который исправляет ошибку перезаписи строковых ключей в multiarrays:

# Flatten a multidimensional array to one dimension, optionally preserving keys.
# $array - the array to flatten
# $preserve_keys - 0 (default) to not preserve keys, 1 to preserve string keys only, 2 to preserve all keys
# $out - internal use argument for recursion

function flatten_array($array, $preserve_keys = 2, &$out = array(), &$last_subarray_found) 
{
        foreach($array as $key => $child)
        {
            if(is_array($child))
            {
                $last_subarray_found = $key;
                $out = flatten_array($child, $preserve_keys, $out, $last_subarray_found);
            }
            elseif($preserve_keys + is_string($key) > 1)
            {
                if ($last_subarray_found)
                {
                    $sfinal_key_value = $last_subarray_found . "_" . $key;
                }
                else
                {
                    $sfinal_key_value = $key;
                }
                $out[$sfinal_key_value] = $child;
            }
            else
            {
                $out[] = $child;
            }
        }

        return $out;
}

Example:
$newarraytest = array();
$last_subarray_found = "";
$this->flatten_array($array, 2, $newarraytest, $last_subarray_found);
1  
2011-08-31 14:46:50 
/*consider $mArray as multidimensional array and $sArray as single dimensional array
this code will ignore the parent array
*/

function flatten_array2($mArray) {
    $sArray = array();

    foreach ($mArray as $row) {
        if ( !(is_array($row)) ) {
            if($sArray[] = $row){
            }
        } else {
            $sArray = array_merge($sArray,flatten_array2($row));
        }
    }
    return $sArray;
}
1  
2011-12-03 05:50:43

вы можете попробовать это:

function flat_an_array($a)
{
    foreach($a as $i)
    {
        if(is_array($i)) 
        {
            if($na) $na = array_merge($na,flat_an_array($i));
            else $na = flat_an_array($i);
        }
        else $na[] = $i;
    }
    return $na;
}
1  
2012-02-21 17:17:47

Если вы согласны с потерей ключей массива, вы можете сгладить многомерный массив, используя рекурсивное замыкание в качестве обратного вызова, который использует array_values (), убедившись, что этот обратный вызов является параметром для array_walk (), следующим образом.

<?php  

$array = [1,2,3,[5,6,7]];
$nu_array = null;
$callback = function ( $item ) use(&$callback, &$nu_array) {
    if (!is_array($item)) {
    $nu_array[] = $item;
    }
    else
    if ( is_array( $item ) ) {
     foreach( array_values($item) as $v) {
         if ( !(is_array($v))) {
             $nu_array[] = $v;
         }
         else
         { 
             $callback( $v );
         continue;
         }    
     }
    }
};

array_walk($array, $callback);
print_r($nu_array);

один недостаток предыдущего примера заключается в том, что он включает в себя гораздо больше кода, чем следующее решение, которое использует array_walk_recursive() вместе с упрощенным обратным вызовом:

<?php  

$array = [1,2,3,[5,6,7]];

$nu_array = [];
array_walk_recursive($array, function ( $item ) use(&$nu_array )
                     {
                         $nu_array[] = $item;
                     }
);
print_r($nu_array);

посмотреть live код

этот пример кажется предпочтительнее предыдущего, скрывая подробности о том, как значения извлекаются из многомерного массива. Конечно, итерация происходит, но влечет ли она за собой рекурсию или структуру(ы) управления, вы узнаете только из просмотра массив.c. Поскольку функциональное программирование фокусируется на вводе и выводе, а не на мелочах получения результата, конечно, можно оставаться безразличным к тому, как происходит закулисная итерация, то есть пока перспективный работодатель не ставит такой вопрос.

1  
2016-09-17 20:01:16

можно использовать развернуть С нестандартная PHP библиотека (NSPL). Он работает с массивами и любыми итерационными структурами данных.

assert([1, 2, 3, 4, 5, 6, 7, 8, 9] === flatten([[1, [2, [3]]], [[[4, 5, 6]]], 7, 8, [9]]));
0  
2016-05-21 22:40:00

простой подход..Смотрите его через рекурсию..

<?php

function flatten_array($simple){
static $outputs=array();
foreach ( $simple as $value)
{
if(is_array($value)){
    flatten_array($value);
}
else{
    $outputs[]=$value;
}

}
return $outputs;
}

$eg=['s'=>['p','n'=>['t']]];
$out=flatten_array($eg);
print_r($out);

?>
0  
2016-12-11 15:18:58

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

function valuelist($array, $array_column) {
    $return = array();
    foreach($array AS $row){
        $return[]=$row[$array_column];
    };
    return $return;
};

пример:

учитывая get_role_action$=

array(3) {
  [0]=>
  array(2) {
    ["ACTION_CD"]=>
    string(12) "ADD_DOCUMENT"
    ["ACTION_REASON"]=>
    NULL
  }
  [1]=>
  array(2) {
    ["ACTION_CD"]=>
    string(13) "LINK_DOCUMENT"
    ["ACTION_REASON"]=>
    NULL
  }
  [2]=>
  array(2) {
    ["ACTION_CD"]=>
    string(15) "UNLINK_DOCUMENT"
    ["ACTION_REASON"]=>
    NULL
  }
}

чем $variables['role_action_list']=valuelist($get_role_action, 'ACTION_CD'); в результате:

$variables["role_action_list"]=>
  array(3) {
    [0]=>
    string(12) "ADD_DOCUMENT"
    [1]=>
    string(13) "LINK_DOCUMENT"
    [2]=>
    string(15) "UNLINK_DOCUMENT"
  }

оттуда вы можете выполнять поиск значений следующим образом:

if( in_array('ADD_DOCUMENT', $variables['role_action_list']) ){
    //do something
};
-1  
2014-07-23 23:44:54

все это не сработало для меня ... так что пришлось работать самому. работает просто отлично:

function arrayFlat($arr){
$out = '';
    foreach($arr as $key => $value){

        if(!is_array($value)){
            $out .= $value.',';
        }else{
            $out .= $key.',';
            $out .= arrayFlat($value);
        }

    }
    return trim($out,',');
}


$result = explode(',',arrayFlat($yourArray));
echo '<pre>';
print_r($result);
echo '</pre>';
-1  
2015-09-25 09:38:29

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

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;
}
-1  
2015-11-12 00:47:51

Comments

    Ничего не найдено.
Click here to cancel reply.