दिलचस्प पोस्ट
मैं दूरी में कैसे माप सकता हूं और जावा में दो अक्षांश + अक्षांश अंक के आधार पर एक बाउंडिंग बॉक्स बना सकता हूं? एंड्रॉइड / जावा – फेसबुक वॉल को सरल पाठ पोस्ट करें? एंड्रॉइड 1.6: "android.view.WindowManager $ BadTokenException: खिड़की जोड़ने में असमर्थ – टोकन रिक्त एक आवेदन के लिए नहीं है" मैं एक्लिप्स आउटपुट कंसोल की क्षमता कैसे बढ़ाऊं? कैसे एक चर का उपयोग करने के लिए अन्य चर के नाम के रूप में bash एसडी कार्ड से ईमेल भेजने की कोशिश कर रहा है I एक अलग रंग के साथ मानक एंड्रॉइड बटन मैट्रैट में दो वैक्टर से वेक्टरयुक्त कोड का उपयोग करने के लिए सभी जोड़े कैसे उत्पन्न करें? IDisposable इंटरफ़ेस का उचित उपयोग क्यों क्लिक करें () के बजाय jQuery पर () का उपयोग करें Z- अनुक्रमणिका क्यों काम नहीं करता है? ब्राउज़र का बैक बटन अक्षम करें कस्टम एटर्स को परिभाषित करना स्ट्रिंग के रूप में दिए गए अभिव्यक्ति का मूल्यांकन करें डिफ़ॉल्ट समापन बिंदु तत्व नहीं मिला

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

क्या पुनरावृत्ति या संदर्भों का उपयोग किए बिना एक (द्वि / बहु) आयामी सरणी समतल करने के लिए, PHP में संभव है?

मुझे केवल मूल्यों में दिलचस्पी है ताकि चाबियाँ अनदेखी की जा सकें, मैं array_map() और array_values() की रेखाओं में सोच रहा हूं।

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

आप पुनरावर्तन "छिपाने" के लिए मानक 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, " "; } 

प्रिंट

 1 2 3 4 5 6 7 8 9 

PHP 5.3 की तरह कम से कम समाधान array_walk_recursive() लगता है, जिसमें नए क्लोजर सिंटैक्स होते हैं:

 function flatten(array $array) { $return = array(); array_walk_recursive($array, function($a) use (&$return) { $return[] = $a; }); return $return; } 

2 आयामी सरणी के समाधान

कृपया यह प्रयास करें:

 $array = your array $result = call_user_func_array('array_merge', $array); echo "<pre>"; print_r($result); 

संपादित करें: 21-अगस्त -13

यह समाधान है जो बहुआयामी सरणी के लिए काम करता है:

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

रेफरी: http://php.net/manual/en/function.call-user-func-array.php

W / o recursion समतल करने के लिए (जैसा आपने पूछा है), आप एक स्टैक का उपयोग कर सकते हैं। स्वाभाविक रूप से आप इसे स्वयं के एक समारोह में रख सकते हैं array_flatten निम्नलिखित एक संस्करण है जो w / o कुंजी का काम करता है:।

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

तत्वों को उनके क्रम में संसाधित किया जाता है क्योंकि उप-ऑब्जेक्ट्स को स्टैक के शीर्ष पर स्थानांतरित किया जाएगा, वे आगे संसाधित किए जाएंगे

इसके अलावा, कुंजी को भी खाते में लेना संभव है, हालांकि, आपको स्टैक को संभालने के लिए एक अलग रणनीति की आवश्यकता होगी। इसकी आवश्यकता है क्योंकि आपको उप-एरे में संभावित डुप्लिकेट कीज़ से निपटने की आवश्यकता है। किसी संबंधित प्रश्न में एक समान उत्तर: कुंजी को संरक्षित करते समय PHP बहुआयामी सरणी के माध्यम से चलते हैं

मुझे विशेष रूप से यकीन नहीं है, लेकिन द्वितीय ने इस पर अतीत में परीक्षण किया था: पुनरावर्ती RecurisiveIterator ने रिकर्सन का उपयोग किया है, इसलिए यह आपके लिए वास्तव में क्या जरूरत है पर निर्भर करता है। ढेर के आधार पर पुनरावर्ती आवर्ती बनाने के लिए संभव होना चाहिए:

 foreach(new FlatRecursiveArrayIterator($array) as $key => $value) { echo "** ($key) $value\n"; } 

डेमो

मैंने इसे इतनी दूर नहीं बनाया है, RecursiveIterator पर आधारित स्टैक को लागू करने के लिए जो मुझे अच्छा लगता है।

पुनरावर्तन का उपयोग करता है उम्मीद है कि यह कितना जटिल नहीं है, यह देखने पर कि आपका पुनरावर्तन का डर खत्म हो जाएगा, जब आप देखेंगे कि यह कितना जटिल नहीं है।

 function flatten($array) { if (!is_array($array)) { // nothing to do if it's not an array return array($array); } $result = array(); foreach ($array as $value) { // explode the sub-array, and add the parts $result = array_merge($result, flatten($value)); } return $result; } $arr = array('foo', array('nobody', 'expects', array('another', 'level'), 'the', 'Spanish', 'Inquisition'), 'bar'); echo '<ul>'; foreach (flatten($arr) as $value) { echo '<li>', $value, '</li>'; } echo '<ul>'; 

आउटपुट:

 <ul><li>foo</li><li>nobody</li><li>expects</li><li>another</li><li>level</li><li>the</li><li>Spanish</li><li>Inquisition</li><li>bar</li><ul> 

बस सोचा कि मैं यह बताता हूं कि यह एक गुना है, तो सरणीरेड का इस्तेमाल किया जा सकता है:

 array_reduce($my_array, 'array_merge', array()); 

संपादित करें: ध्यान दें कि यह किसी भी स्तर को समतल करने के लिए बनाया जा सकता है। हम इसे कई तरह से कर सकते हैं:

 // Reduces one level $concat = function($x) { return array_reduce($x, 'array_merge', array()); }; // We can compose $concat with itself $n times, then apply it to $x // This can overflow the stack for large $n $compose = function($f, $g) { return function($x) use ($f, $g) { return $f($g($x)); }; }; $identity = function($x) { return $x; }; $flattenA = function($n) use ($compose, $identity, $concat) { return function($x) use ($compose, $identity, $concat, $n) { return ($n === 0)? $x : call_user_func(array_reduce(array_fill(0, $n, $concat), $compose, $identity), $x); }; }; // We can iteratively apply $concat to $x, $n times $uncurriedFlip = function($f) { return function($a, $b) use ($f) { return $f($b, $a); }; }; $iterate = function($f) use ($uncurriedFlip) { return function($n) use ($uncurriedFlip, $f) { return function($x) use ($uncurriedFlip, $f, $n) { return ($n === 0)? $x : array_reduce(array_fill(0, $n, $f), $uncurriedFlip('call_user_func'), $x); }; }; }; $flattenB = $iterate($concat); // Example usage: $apply = function($f, $x) { return $f($x); }; $curriedFlip = function($f) { return function($a) use ($f) { return function($b) use ($f, $a) { return $f($b, $a); }; }; }; var_dump( array_map( call_user_func($curriedFlip($apply), array(array(array('A', 'B', 'C'), array('D')), array(array(), array('E')))), array($flattenA(2), $flattenB(2)))); 

बेशक, हम भी लूपों का उपयोग कर सकते हैं लेकिन सवाल array_map या array_values ​​की तर्ज पर एक संयोजक फ़ंक्शन के लिए पूछते हैं

सरल और एक-लाइनर का जवाब।

 function flatten_array(array $array) { return iterator_to_array( new \RecursiveIteratorIterator(new \RecursiveArrayIterator($array))); } 

उपयोग:

 $array = [ 'name' => 'Allen Linatoc', 'profile' => [ 'age' => 21, 'favourite_games' => [ 'Call of Duty', 'Titanfall', 'Far Cry' ] ] ]; print_r( flatten_array($array) ); 

आउटपुट (PsySH में):

 Array ( [name] => Allen Linatoc [age] => 21 [0] => Call of Duty [1] => Titanfall [2] => Far Cry ) 

अब यह आप पर बहुत सुंदर है कि आप कुंजी को कैसे संभाल लेंगे चियर्स


संपादित करें (2017-03-01)

निगेल एल्डरस्टोन की चिंता / मुद्दे का हवाला देते हुए:

बस स्पष्ट करने के लिए, यह कुंजी को संरक्षित करता है (यहां तक ​​कि अंकीय संख्याएं) ताकि मूल्यों की एक ही कुंजी खो जाती है उदाहरण के लिए $array = ['a',['b','c']] Array ([0] => b, [1] => c ) हो जाती है Array ([0] => b, [1] => c ) 'a' खो गया है क्योंकि 'b' में 0 की भी एक कुंजी है

सिव्ष के जवाब का हवाला देते हुए:

बस ($use_keys) पैरामीटर ($use_keys) रूप में गलत iterator_to_array कॉल में जोड़ें

केवल दो आयामी सरणियां बांटती हैं:

 $arr = [1, 2, [3, 4]]; $arr = array_reduce($arr, function ($a, $b) { return array_merge($a, (array) $b); }, []); // Result: [1, 2, 3, 4] 

यह समाधान गैर-रिकर्सिव है ध्यान दें कि तत्वों का क्रम थोड़ा मिश्रित होगा।

 function flatten($array) { $return = array(); while(count($array)) { $value = array_shift($array); if(is_array($value)) foreach($value as $sub) $array[] = $sub; else $return[] = $value; } return $return; } 

निम्नलिखित सरल कार्य को आज़माएं:

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

इस प्रकार से:

 array ( 'und' => array ( 'profiles' => array ( 0 => array ( 'commerce_customer_address' => array ( 'und' => array ( 0 => array ( 'first_name' => 'First name', 'last_name' => 'Last name', 'thoroughfare' => 'Address 1', 'premise' => 'Address 2', 'locality' => 'Town/City', 'administrative_area' => 'County', 'postal_code' => 'Postcode', ), ), ), ), ), ), ) 

आपको मिला:

 array ( 'first_name' => 'First name', 'last_name' => 'Last name', 'thoroughfare' => 'Address 1', 'premise' => 'Address 2', 'locality' => 'Town/City', 'administrative_area' => 'County', 'postal_code' => 'Postcode', ) 

आप इसे औज़ो गुड्स के साथ कर सकते हैं:

  $result = Arrays::flatten($multidimensional); 

देखें: यहाँ

यह ट्रिक संदर्भ द्वारा दोनों स्रोत और गंतव्य arrays को गुजर रहा है।

 function flatten_array(&$arr, &$dst) { if(!isset($dst) || !is_array($dst)) { $dst = array(); } if(!is_array($arr)) { $dst[] = $arr; } else { foreach($arr as &$subject) { flatten_array($subject, $dst); } } } $recursive = array('1', array('2','3',array('4',array('5','6')),'7',array(array(array('8'),'9'),'10'))); echo "Recursive: \r\n"; print_r($recursive); $flat = null; flatten_array($recursive, $flat); echo "Flat: \r\n"; print_r($flat); // If you change line 3 to $dst[] = &$arr; , you won't waste memory, // since all you're doing is copying references, and imploding the array // into a string will be both memory efficient and fast:) echo "String:\r\n"; echo implode(',',$flat); 
 /** * For merging values of a multidimensional array into one * * $array = [ * 0 => [ * 0 => 'a1', * 1 => 'b1', * 2 => 'c1', * 3 => 'd1' * ], * 1 => [ * 0 => 'a2', * 1 => 'b2', * 2 => 'c2', * ] * ]; * * becomes : * * $array = [ * 0 => 'a1', * 1 => 'b1', * 2 => 'c1', * 3 => 'd1', * 4 => 'a2', * 5 => 'b2', * 6 => 'c2', * * ] */ array_reduce ( $multiArray , function ($lastItem, $currentItem) { $lastItem = $lastItem ?: array(); return array_merge($lastItem, array_values($currentItem)); } ); 

Gist स्निपेट

PHP 5.2 के लिए

 function flatten(array $array) { $result = array(); if (is_array($array)) { foreach ($array as $k => $v) { if (is_array($v)) { $result = array_merge($result, flatten($v)); } else { $result[] = $v; } } } return $result; } 

यह संस्करण गहरा, उथले या विशिष्ट स्तरों की संख्या कर सकता है:

 /** * @param array|object $array array of mixed values to flatten * @param int|boolean $level 0:deep, 1:shallow, 2:2 levels, 3... * @return array */ function flatten($array, $level = 0) { $level = (int) $level; $result = array(); foreach ($array as $i => $v) { if (0 <= $level && is_array($v)) { $v = flatten($v, $level > 1 ? $level - 1 : 0 - $level); $result = array_merge($result, $v); } elseif (is_int($i)) { $result[] = $v; } else { $result[$i] = $v; } } return $result; } 

क्योंकि यहां पर कोड डरावना लग रहा है। यहां एक फ़ंक्शन है जो बहुआयामी सरणी को html फ़ॉर्म संगत वाक्यविन्यास में बदल देगा, लेकिन यह पढ़ने में आसान है।

 /** * Flattens a multi demensional array into a one dimensional * to be compatible with hidden html fields. * * @param array $array * Array in the form: * array( * 'a' => array( * 'b' => '1' * ) * ) * * @return array * Array in the form: * array( * 'a[b]' => 1, * ) */ function flatten_array($array) { // Continue until $array is a one-dimensional array. $continue = TRUE; while ($continue) { $continue = FALSE; // Walk through top and second level of $array and move // all values in the second level up one level. foreach ($array as $key => $value) { if (is_array($value)) { // Second level found, therefore continue. $continue = TRUE; // Move each value a level up. foreach ($value as $child_key => $child_value) { $array[$key . '[' . $child_key . ']'] = $child_value; } // Remove second level array from top level. unset($array[$key]); } } } return $array; } 

यदि आप वास्तव में एक पुनरावर्तन पसंद नहीं करते हैं … इसके बजाय स्थानांतरण की कोशिश करें 🙂

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

नोट: इस सरल संस्करण में, यह सरणी कुंजियों का समर्थन नहीं करता है।

एक संदर्भ का उपयोग करते हुए यह मेरा समाधान है:

 function arrayFlatten($array_in, &$array_out){ if(is_array($array_in)){ foreach ($array_in as $element){ arrayFlatten($element, $array_out); } } else{ $array_out[] = $array_in; } } $arr1 = array('1', '2', array(array(array('3'), '4', '5')), array(array('6'))); arrayFlatten($arr1, $arr2); echo "<pre>"; print_r($arr2); echo "</pre>"; 
 <?php //recursive solution //test array $nested_array = [[1,2,[3]],4,[5],[[[6,[7=>[7,8,9,10]]]]]]; /*----------------------------------------- function call and return result to an array ------------------------------------------*/ $index_count = 1; $flatered_array = array(); $flatered_array = flat_array($nested_array, $index_count); /*----------------------------------------- Print Result -----------------------------------------*/ echo "<pre>"; print_r($flatered_array); /*----------------------------------------- function to flaten an array -----------------------------------------*/ function flat_array($nested_array, & $index_count, & $flatered_array) { foreach($nested_array AS $key=>$val) { if(is_array($val)) { flat_array($val, $index_count, $flatered_array); } else { $flatered_array[$index_count] = $val; ++$index_count; } } return $flatered_array; } ?> 

मेरा मानना ​​है कि यह कोई म्यूटेशन और न ही अपरिचित वर्गों का उपयोग किए बिना सबसे साफ समाधान है।

 <?php function flatten($array) { return array_reduce($array, function($acc, $item){ return array_merge($acc, is_array($item) ? flatten($item) : [$item]); }, []); } // usage $array = [1, 2, [3, 4], [5, [6, 7]], 8, 9, 10]; print_r(flatten($array)); 

यहां एक सरल दृष्टिकोण है:

 $My_Array = array(1,2,array(3,4, array(5,6,7), 8), 9); function checkArray($value) { foreach ($value as $var) { if ( is_array($var) ) { checkArray($var); } else { echo $var; } } } checkArray($My_Array); 

PHP 5.6 और ऊपर में आप array_merge साथ दो आयामी arrays को बाहरी ऑपरेटर को खोलने के बाद ... ऑपरेटर के साथ array_merge कर सकते हैं। कोड सरल और स्पष्ट है

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

लेकिन यह काम नहीं करता है जब बाह्य सरणी में संख्यात्मक कुंजियां नहीं होतीं उस स्थिति में, आपको पहले array_values को कॉल करना होगा।

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

मुझे HTML इनपुट प्रारूप में PHP बहुआयामी सरणी का प्रतिनिधित्व करने की आवश्यकता है I

 $test = [ 'a' => [ 'b' => [ 'c' => ['a', 'b'] ] ], 'b' => 'c', 'c' => [ 'd' => 'e' ] ]; $flatten = function ($input, $parent = []) use (&$flatten) { $return = []; foreach ($input as $k => $v) { if (is_array($v)) { $return = array_merge($return, $flatten($v, array_merge($parent, [$k]))); } else { if ($parent) { $key = implode('][', $parent) . '][' . $k . ']'; if (substr_count($key, ']') != substr_count($key, '[')) { $key = preg_replace('/\]/', '', $key, 1); } } else { $key = $k; } $return[$key] = $v; } } return $return; }; die(var_dump( $flatten($test) )); array(4) { ["a[b][c][0]"]=> string(1) "a" ["a[b][c][1]"]=> string(1) "b" ["b"]=> string(1) "c" ["c[d]"]=> string(1) "e" } 

यदि आपके पास ऑब्जेक्ट्स की एक सरणी है और इसे नोड के साथ समतल करना चाहते हैं, तो बस इस फ़ंक्शन का उपयोग करें:

 function objectArray_flatten($array,$childField) { $result = array(); foreach ($array as $node) { $result[] = $node; if(isset($node->$childField)) { $result = array_merge( $result, objectArray_flatten($node->$childField,$childField) ); unset($node->$childField); } } return $result; } 

क्या पुनरावृत्ति या संदर्भों का उपयोग किए बिना एक (द्वि / बहु) आयामी सरणी समतल करने के लिए, PHP में संभव है?

PHP 7 के अनुसार, मुझे पता नहीं मैंने एक समाधान बनाया जो मैं array_moonwalk कॉल करता array_moonwalk , जो दोनों संदर्भों का उपयोग करता है और एक बहुआयामी सरणी को समतल और array_moonwalk और बहुआयामी सरणी पुनर्निर्माण के लिए पाया गया प्रत्येक डुप्लिकेट के लिए गहनतम नोड की गहराई को संरक्षित करता है।

array_walk का उपयोग किए बिना अलग-अलग गहराई पर पत्ती के नोड्स के दोहराव को संभालता है, और array_walk का लाभ उठाने के लिए अब तक का एकमात्र उत्तर है। प्रदर्शन के लिए परीक्षण नहीं किया गया YMMV।