कैसे PHP में सरल करने के लिए एक बहुआयामी सरणी "समतल" करने के लिए?

Question 1

यह शायद शुरुआती सवाल है, लेकिन मैं पहले से ही लंबे समय से प्रलेखन के माध्यम से जा रहा हूं और मुझे कोई समाधान नहीं मिल रहा है। मैंने सोचा कि मैं प्रत्येक आयाम के लिए इनकोड का उपयोग कर सकता हूं और फिर उन स्ट्रिंग्स को एक साथ रख str_splitकर नया सरल एरे बना सकता हूं । हालाँकि मैं कभी नहीं जानता कि अगर ज्वाइन पैटर्न भी मूल्यों में नहीं है और ऐसा करने के बाद str_splitमेरा मूल मूल्य टूट सकता है।

क्या combine($array1, $array2)बहुआयामी सरणी के अंदर सरणियों के लिए कुछ ऐसा है ?

Question 2

उपयोग 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)

Question 3

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

Question 4

यह एक लाइन है, सुपर आसान उपयोग करने के लिए:

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

अनाम फ़ंक्शन / बंद के अंदर यह समझना बहुत आसान है। $vअपने का मूल्य है $original_array।

Question 5

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

Question 6

यदि आपके पास विशेष रूप से सरणियों की एक सरणी है जो एक स्तर से अधिक गहराई तक नहीं जाती है (एक उपयोग मामला मुझे आम लगता है) तो आप दूर 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)
}

प्रभावी रूप से एरे के लिए तर्कों के रूप में एरे के लिए ऐरे को सरणी सूची में बदल देता है array_merge।

Question 7

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

Question 8

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

Question 9

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 
)

Question 10

एक गैर-पुनरावर्ती समाधान (लेकिन आदेश-विनाश):

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

Question 11

PHP> = 5.3 में और ल्यूक एम के उत्तर (पहले वाले) के आधार पर आप इस तरह से क्लोजर का उपयोग कर सकते हैं

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

मुझे यह पसंद है क्योंकि मुझे create_function () का उपयोग करते समय फ़ंक्शन के कोड को उद्धरण के साथ घेरना नहीं पड़ता है

Question 12

उच्च-क्रम फ़ंक्शंस का उपयोग करना (ध्यान दें: मैं इनलाइन अनाम फ़ंक्शंस का उपयोग कर रहा हूं , जो 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()
    );
}

Question 13

अराजकता द्वारा प्रस्तुत पिछले उदाहरण फ़ंक्शन पर आधारित एक नया दृष्टिकोण, जो मल्टीरेज़ में स्ट्रिंग कुंजियों को अधिलेखित करने के बग को ठीक करता है:

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

Question 14

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

Question 15

आप यह कोशिश कर सकते हैं:

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

Question 16

यदि आप सरणी कुंजियों को खो देने के साथ ठीक हैं, तो आप कॉलबैक के रूप में पुनरावर्ती बंद का उपयोग करके एक बहुआयामी सरणी को समतल कर सकते हैं जो 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);

लाइव कोड देखें

यह उदाहरण पिछले एक के लिए बेहतर लगता है, इस बारे में विवरण छिपाते हुए कि मूल्यों को एक बहुआयामी सरणी से कैसे निकाला जाता है। निश्चित रूप से, पुनरावृत्ति होती है, लेकिन क्या यह पुनरावृत्ति या नियंत्रण संरचना (ओं) को पूरा करती है, आप केवल perusing array.c से ही जान पाएंगे । चूंकि कार्यात्मक प्रोग्रामिंग एक परिणाम प्राप्त करने के minutiae के बजाय इनपुट और आउटपुट पर ध्यान केंद्रित करती है, निश्चित रूप से कोई भी इस बारे में असंबद्ध रह सकता है कि पीछे-पीछे का दृश्य कैसे होता है, जब तक कि एक परिप्रेक्ष्य नियोक्ता इस तरह का सवाल नहीं करता है।

Question 17

मुझे बहुस्तरीय सरणी को एक में बदलने का एक सरल तरीका मिला। मैं फ़ंक्शन "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;

Question 18

नेक्रोबंपिंग के लिए खेद है, लेकिन प्रदान किए गए उत्तरों में से किसी ने भी मुझे सहज रूप से "एक बहुआयामी सरणी" के रूप में समझा। अर्थात् यह मामला:

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

अपनी पसंद के अनुसार $ उपसर्ग और '_' विभाजक को संशोधित करें।

यहां खेल का मैदान: https://3v4l.org/0B8hf

Question 19

आप गैर-मानक PHP पुस्तकालय (NSPL) से समतल फ़ंक्शन का उपयोग कर सकते हैं । यह सरणियों और किसी भी चलने योग्य डेटा संरचनाओं के साथ काम करता है।

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

Question 20

सरल दृष्टिकोण। इसे पुनरावृत्ति के माध्यम से देखें।

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

?>

Question 21

किसी को यह उपयोगी लग सकता है, मुझे कुछ आयामों में समतल करने में एक समस्या थी, मैं इसे अंतिम आयाम कहूंगा, उदाहरण के लिए, अगर मेरे पास सरणी है:

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

Question 22

यदि आप एक विशेष कुंजी के लिए सिर्फ मूल्यों में रुचि रखते हैं, तो आपको यह तरीका उपयोगी लग सकता है:

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

Question 23

इस काम के किसी भी मेरे लिए काम नहीं किया ... इसलिए इसे खुद चलाना था। ठीक काम करता है:

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

Question 24

बहु-आयामी सरणी को देखते हुए और इसे एक-आयामी में परिवर्तित करके, उन सभी मूल्यों को परेशान करके किया जा सकता है, जो सरणियाँ हैं और उन्हें पहले आयाम में सहेज रहे हैं, उदाहरण के लिए:

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