यहाँ मेरा बहुत ही सरल, PHP 5.5-संगत समाधान है:
function array_map_assoc(callable $f, array $a) {
return array_column(array_map($f, array_keys($a), $a), 1, 0);
}
आपके द्वारा आपूर्ति की जाने वाली कॉल करने योग्य सामग्री को दो मानों के साथ एक सरणी को वापस करना चाहिए, अर्थात return [key, value]। array_mapइसलिए आंतरिक कॉल सरणियों की एक सरणी का उत्पादन करता है। यह तब एकल-आयाम सरणी में वापस परिवर्तित हो जाता है array_column।
प्रयोग
$ordinals = [
'first' => '1st',
'second' => '2nd',
'third' => '3rd',
];
$func = function ($k, $v) {
return ['new ' . $k, 'new ' . $v];
};
var_dump(array_map_assoc($func, $ordinals));
उत्पादन
array(3) {
["new first"]=>
string(7) "new 1st"
["new second"]=>
string(7) "new 2nd"
["new third"]=>
string(7) "new 3rd"
}
आंशिक आवेदन
मामले में आपको विभिन्न सरणियों के साथ कई बार फ़ंक्शन का उपयोग करने की आवश्यकता होती है, लेकिन एक ही मैपिंग फ़ंक्शन, आप आंशिक फ़ंक्शन अनुप्रयोग (' करी ' से संबंधित ) नामक कुछ कर सकते हैं , जो आपको केवल आह्वान पर डेटा सरणी में पास करने की अनुमति देता है:
function array_map_assoc_partial(callable $f) {
return function (array $a) use ($f) {
return array_column(array_map($f, array_keys($a), $a), 1, 0);
};
}
...
$my_mapping = array_map_assoc_partial($func);
var_dump($my_mapping($ordinals));
जो समान आउटपुट देता है, दिया $funcऔर $ordinalsपहले जैसा है।
नोट: यदि आपका मैप किया गया फ़ंक्शन दो अलग-अलग इनपुटों के लिए एक ही कुंजी देता है, तो बाद की कुंजी से संबंधित मान जीत जाएगा। array_map_assocपूर्व की कुंजियों को जीतने के लिए इनपुट सरणी और आउटपुट परिणाम को उलट दें। (मेरे उदाहरण में दी गई कुंजियाँ टकरा नहीं सकतीं क्योंकि वे स्रोत सरणी की कुंजी को सम्मिलित करती हैं, जो बदले में विशिष्ट होनी चाहिए।)
विकल्प
निम्नलिखित उपरोक्त का एक प्रकार है, जो कुछ के लिए अधिक तार्किक साबित हो सकता है, लेकिन इसके लिए PHP 5.6 की आवश्यकता होती है:
function array_map_assoc(callable $f, array $a) {
return array_merge(...array_map($f, array_keys($a), $a));
}
इस संस्करण में, आपका दिया गया फ़ंक्शन (जिस पर डेटा सरणी मैप की गई है) इसके बजाय एक पंक्ति, यानी के साथ एक सहयोगी सरणी वापस करना चाहिए return [key => value]। तब कॉल करने योग्य मैपिंग का परिणाम बस अनपैक किया गया और पास किया गया array_merge। पहले की तरह, डुप्लिकेट कुंजी को वापस करने के परिणामस्वरूप बाद के मूल्यों की जीत होगी।
nb Alex83690 ने एक टिप्पणी में कहा है कि array_replaceयहाँ के उपयोग से array_mergeपूर्णांक कुंजियाँ संरक्षित होंगी। array_replaceइनपुट सरणी को संशोधित नहीं करता है, इसलिए कार्यात्मक कोड के लिए सुरक्षित है।
यदि आप PHP 5.3 से 5.5 पर हैं, तो निम्नलिखित बराबर है। यह array_reduceद्विआधारी +सरणी ऑपरेटर का उपयोग करता है और परिणामी दो-आयामी सरणी को एक-आयामी सरणी में परिवर्तित करने के लिए कुंजी को संरक्षित करता है:
function array_map_assoc(callable $f, array $a) {
return array_reduce(array_map($f, array_keys($a), $a), function (array $acc, array $a) {
return $acc + $a;
}, []);
}
प्रयोग
इस प्रकार इन दोनों प्रकारों का उपयोग किया जाएगा:
$ordinals = [
'first' => '1st',
'second' => '2nd',
'third' => '3rd',
];
$func = function ($k, $v) {
return ['new ' . $k => 'new ' . $v];
};
var_dump(array_map_assoc($func, $ordinals));
नोट =>के बदले ,में $func।
आउटपुट पहले जैसा ही है, और प्रत्येक को पहले की तरह ही आंशिक रूप से लागू किया जा सकता है।
सारांश
मूल प्रश्न का लक्ष्य कॉल के आह्वान को अधिक से अधिक जटिल कार्य करने की कीमत पर यथासंभव सरल बनाना है; विशेष रूप से, डेटा सरणी को एक तर्क के रूप में पारित करने की क्षमता है, बिना कुंजियों और मूल्यों के विभाजन के। इस उत्तर की शुरुआत में दिए गए फ़ंक्शन का उपयोग करना:
$test_array = ["first_key" => "first_value",
"second_key" => "second_value"];
$array_map_assoc = function (callable $f, array $a) {
return array_column(array_map($f, array_keys($a), $a), 1, 0);
};
$f = function ($key, $value) {
return [$key, $key . ' loves ' . $value];
};
var_dump(array_values($array_map_assoc($f, $test_array)));
या, केवल इस प्रश्न के लिए, हम array_map_assoc()आउटपुट कुंजियों को छोड़ने वाले फ़ंक्शन का सरलीकरण कर सकते हैं , क्योंकि प्रश्न उनके लिए नहीं पूछता है:
$test_array = ["first_key" => "first_value",
"second_key" => "second_value"];
$array_map_assoc = function (callable $f, array $a) {
return array_map($f, array_keys($a), $a);
};
$f = function ($key, $value) {
return $key . ' loves ' . $value;
};
var_dump($array_map_assoc($f, $test_array));
तो जवाब नहीं है , आप कॉल करने से बच सकते हैं array_keys, लेकिन आप उस स्थान को अलग कर सकते हैं जहां array_keysएक उच्च-क्रम फ़ंक्शन में बुलाया जाता है, जो काफी अच्छा हो सकता है।