PHP에서 다차원 어레이를 단순 어레이로 "평탄화"하는 방법은 무엇입니까?

PHP에서 다차원 어레이를 단순 어레이로 "평탄화"하는 방법은 무엇입니까?

이 질문에는 이미 답변이 있습니다.

다차원 어레이를 평평하게 하는 방법 (31 회답)

닫힘작년.

초심자 질문일 수도 있지만, 저는 이미 더 오랜 시간 동안 문서를 검토 중이고 해결책을 찾을 수 없습니다.를 사용하고 , 그을 innode와 함께 놓을 수 했습니다.str_split새로운 심플 어레이를 만듭니다., 는 알 수 에 doing을 한 후에 합니다.str_split★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★♪

뭐이 is 거?combine($array1, $array2)다차원 어레이 내부의 어레이에 사용할 수 있습니까?

$array  = your array

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

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

참조: 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);

이것은 1행으로 사용하기 쉬운 SUPER입니다.

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

익명 함수/폐쇄 내부는 매우 이해하기 쉽습니다. $v입니다.$original_array.

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)로 테스트 완료 (빌드: 2018년 3월 16일 12:32:06)

이상의 인 사용 사례)를 넘지 있는 경우는, 「1」로 할 수 .array_merge이치노

<?php

$notFlat = [[1,2],[3,4]];
$flat = array_merge(...$notFlat);
var_dump($flat);

출력:

array(4) {
  [0]=>
  int(1)
  [1]=>
  int(2)
  [2]=>
  int(3)
  [3]=>
  int(4)
}

배열을 splat 합니다.array_merge.

// $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

Necrobumping 죄송합니다.이러한 답변 중 직관적으로 '다차원 어레이의 평탄화'라고 이해되는 것은 없었습니다.즉, 이 경우:

[
  'a' => [
    'b' => 'value',
  ]
]

제공된 모든 솔루션이 이 시스템을 평평하게 만들 것입니다.['value']깊이에 가 없어지고 덮어쓰게 이 '을'은 '을'은 '을'은 '을'은 '을'은 '을'이다.

나는 다음과 같은 결과를 얻고 싶었다.

[
  'a_b' => 'value',
]

array_walk_recursive은 현재않기 에, 단순한.

function flatten($array, $prefix = '') {
    $return = [];
    foreach ($array as $key => $value) {
        if (is_array($value)) {
            $return = array_merge($return, flatten($value, $prefix . $key . '_'));
        } else {
            $return[$prefix . $key] = $value;
        }
    }
    return $return;
}

$prefix와 '_' 구분 기호를 원하는 대로 수정하십시오.

Playground는 이쪽: https://3v4l.org/0B8hf

위임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

비재귀적 솔루션(단, 주문 파괴):

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

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

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 
)

PHP>=5.3에서는 Luc M의 답변(첫 번째 답변)에 따라 다음과 같은 폐쇄를 사용할 수 있습니다.

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

create_function()을 사용할 때처럼 함수 코드를 따옴표로 둘러싸지 않아도 되기 때문에 매우 좋습니다.

고차 함수 사용(주의: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()
    );
}

멀티레벨 어레이를 하나로 변환하는 간단한 방법을 찾았습니다.배열을 URL 문자열로 변환하는 함수 "http_build_query" 를 사용합니다.그런 다음 문자열을 폭발로 분할하고 값을 디코딩합니다.

여기 샘플이 있습니다.

$converted = http_build_query($data);
$rows = explode('&', $converted);
$output = array();
foreach($rows AS $k => $v){
   list($kk, $vv) = explode('=', $v);
   $output[ urldecode($kk) ] =  urldecode($vv);
}
return $output;

카오스에 의해 송신된 앞의 예에 근거한 새로운 어프로치에서는, 멀티 어레이로 스트링 키의 덮어쓰기 오류를 수정하고 있습니다.

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

/*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;
}

다음과 같이 시험해 볼 수 있습니다.

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

어레이 키가 손실되어도 문제가 없다면 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);

라이브 코드 참조

이 예제는 앞의 예보다 더 좋은 것 같습니다.다차원 배열에서 값을 추출하는 방법에 대한 자세한 내용은 숨깁니다.물론 반복이 발생하지만 재귀와 제어구조 중 어느 것을 수반하는지는 array.c를 읽어봐야 알 수 있습니다.함수형 프로그래밍은 결과를 얻기 위한 세부사항보다는 입력과 출력에 초점을 맞추고 있기 때문에, 확실히 배경 반복이 어떻게 일어나는지에 대해서는 무관심할 수 있다. 즉, 원근법적인 고용주가 그러한 질문을 제기할 때까지 말이다.

NSPL(Non-Standard PHP Library)에서 플랫 함수를 사용할 수 있습니다.어레이 및 반복 가능한 데이터 구조에서 작동합니다.

assert([1, 2, 3, 4, 5, 6, 7, 8, 9] === flatten([[1, [2, [3]]], [[[4, 5, 6]]], 7, 8, [9]]));

심플한 어프로치..재귀로 확인..

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

?>

이 방법은 유용하다고 생각되는 사람도 있을 것입니다.어레이를 평탄화하는 데 문제가 있었습니다.마지막 차원이라고 부릅니다.예를 들어 다음과 같은 어레이가 있는 경우입니다.

array (
  'germany' => 
  array (
    'cars' => 
    array (
      'bmw' => 
      array (
        0 => 'm4',
        1 => 'x3',
        2 => 'x8',
      ),
    ),
  ),
  'france' => 
  array (
    'cars' => 
    array (
      'peugeot' => 
      array (
        0 => '206',
        1 => '3008',
        2 => '5008',
      ),
    ),
  ),
)

또는 다음 중 하나를 선택합니다.

array (
  'earth' => 
  array (
    'germany' => 
    array (
      'cars' => 
      array (
        'bmw' => 
        array (
          0 => 'm4',
          1 => 'x3',
          2 => 'x8',
        ),
      ),
    ),
  ),
  'mars' => 
  array (
    'france' => 
    array (
      'cars' => 
      array (
        'peugeot' => 
        array (
          0 => '206',
          1 => '3008',
          2 => '5008',
        ),
      ),
    ),
  ),
)

아래 메서드를 호출하면 두 어레이 모두 결과가 나타납니다.

array (
  0 => 
  array (
    0 => 'm4',
    1 => 'x3',
    2 => 'x8',
  ),
  1 => 
  array (
    0 => '206',
    1 => '3008',
    2 => '5008',
  ),
)

따라서 마지막 어레이 치수로 평탄화하려고 합니다.아래의 방법은 실제로 어떤 레벨에서도 정지하도록 리팩터링할 수 있습니다.

function flattenAggregatedArray($aggregatedArray) {
    $final = $lvls = [];
    $counter = 1;
    $lvls[$counter] = $aggregatedArray;


    $elem = current($aggregatedArray);

    while ($elem){
        while(is_array($elem)){
            $counter++;
            $lvls[$counter] = $elem;
            $elem =  current($elem);
        }

        $final[] = $lvls[$counter];
        $elem = next($lvls[--$counter]);
        while ( $elem  == null){
            if (isset($lvls[$counter-1])){
                $elem = next($lvls[--$counter]);
            }
            else{
                return $final;
            }
        }
    }
}

특정 키의 값에만 관심이 있는 경우 다음 방법이 유용할 수 있습니다.

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

이 모든 게 나한테는 통하지 않아서... 그래서 내가 직접 운영해야 했어.정상적으로 동작합니다.

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차원에 저장하면 다음과 같이 할 수 있습니다.

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

언급URL : https://stackoverflow.com/questions/526556/how-to-flatten-a-multi-dimensional-array-to-simple-one-in-php