PHP: क्या मुझे array_map फ़ंक्शन में इंडेक्स मिल सकता है?

Question

मैं php में एक मानचित्र का उपयोग कर रहा हूँ जैसे:

function func($v) {
    return $v * 2;
}

$values = array(4, 6, 3);
$mapped = array_map(func, $values);
var_dump($mapped);

क्या फ़ंक्शन में मूल्य का सूचकांक प्राप्त करना संभव है?

इसके अलावा - अगर मैं कोड लिख रहा हूं जिसमें सूचकांक की आवश्यकता है, तो क्या मुझे नक्शे के बजाय लूप के लिए उपयोग करना चाहिए?

Answer 1

सुनिश्चित करें कि आप कर सकते हैं, की मदद से array_keys():

function func($v, $k)
{
    // key is now $k
    return $v * 2;
}

$values = array(4, 6, 3);
$mapped = array_map('func', $values, array_keys($values));
var_dump($mapped);

Comments

कूल जवाब, एहसास नहीं हुआ कि आप एक सरणी_मैप () पैड विधि में अतिरिक्त पैरामेट्स पास कर सकते हैं। प्रति दिन कुछ नया सीखें!

— गॉर्डन

@ जॉर्डन हाँ आप array_map()एक मनमानी संख्या के साथ आपूर्ति कर सकते हैं :)

— एरन रोटेवेल

यह एक बहुत ही जोखिम भरा दृष्टिकोण है क्योंकि PHP इस बात की गारंटी नहीं देता है कि उसके द्वारा दी गई चाबियां array_keysउसी क्रम में रहेंगी जैसे मूल सरणी में होती हैं। इस प्रकार आप गलत मानों की मैपिंग कुंजी समाप्त कर सकते हैं। सुरक्षित दृष्टिकोण केवल array_keysदूसरे तर्क के रूप में उपयोग करना है array_mapऔर फिर useकथन के साथ बंद करने के लिए सरणी पास करना है ।

— user487772

मुझे स्पष्ट रूप से समझ में नहीं आ रहा है कि PHP में मैप फ़ंक्शन क्यों नहीं है जो कॉलबैक के दूसरे पैरामीटर के रूप में प्रत्येक तत्व की कुंजी की आपूर्ति करता है।

— फ्लू

@flu PHP ने बिना किसी कारण के ख़राब भाषा का शीर्षक अर्जित नहीं किया।

— XZero

Answer 2

अनाम सरणी पर अनाम फ़ंक्शन की मैपिंग करते समय, कुंजियों तक पहुंचने का कोई तरीका नहीं है:

array_map(
    function($val) use ($foo) { /* ... */ },
    array(key1 => val1,
          key2 => val2,
          /* ... */));

array_reduce को कुंजियों तक पहुँच नहीं मिलती है। array_walk कुंजियों का उपयोग कर सकता है, लेकिन सरणी को संदर्भ द्वारा पारित किया जाता है, जिसके लिए अप्रत्यक्ष की एक परत की आवश्यकता होती है।

कुछ समाधान हैं:

जोड़े की सरणी

यह बुरा है, क्योंकि हम मूल सरणी बदल रहे हैं। प्लस बॉयलरप्लेट "सरणी ()" कॉल सरणी की लंबाई के साथ रैखिक रूप से वृद्धि करते हैं:

array_map(
    function($pair) use ($foo) {
        list($key, $val) = $pair;
        /* ... */
    },
    array(array(key1, val1),
          array(key2, val2),
          /* ... */));

अस्थायी चर

हम मूल सरणी पर कार्य कर रहे हैं, और बॉयलरप्लेट निरंतर है, लेकिन हम आसानी से मौजूदा चर को क्लोब कर सकते हैं:

$i_hope_this_does_not_conflict = array(key1 => val1,
                                       key2 => val2,
                                       /* ... */);
array_map(
    function($key, $val) use ($foo) { /* ... */ },
    array_keys($i_hope_this_does_not_conflict),
    $i_hope_this_does_not_conflict);
unset($i_hope_this_does_not_conflict);

एक शॉट समारोह

हम मौजूदा नामों को रोकने के लिए फ़ंक्शन स्कोप का उपयोग कर सकते हैं, लेकिन "उपयोग" की एक अतिरिक्त परत जोड़ना होगा:

call_user_func(
    function($arr) use ($foo) {
        return array_map(function($key, $val) use ($foo) { /* ... */ },
                         array_keys($arr),
                         $arr);
    },
    array(key1 => val1,
          key2 => val2,
          /* ... */));

बहु-तर्क एक-शॉट फ़ंक्शन

हम उस फ़ंक्शन को परिभाषित करते हैं जिसे हम मूल उपयोग में मैप कर रहे हैं "बॉयलरप्लेट" को रोकने के लिए):

call_user_func(
    function($f, $arr) {
        return array_map($f, array_keys($arr), $arr);
    },
    function($key, $val) use ($foo) { /* ... */ },
    array(key1 => val1,
          key2 => val2,
          /* ... */));

नया समारोह

ध्यान देने वाली बात यह है कि हमारे पिछले एक-शॉट फंक्शन में एक अच्छा, सामान्य हस्ताक्षर है और यह array_map की तरह दिखता है। हम इसे एक नाम देना चाहते हैं और इसे फिर से उपयोग कर सकते हैं:

function array_mapk($f, $arr) {
    return array_map($f, array_keys($arr), $arr);
}

हमारा एप्लिकेशन कोड तब बन जाता है:

array_mapk(
    function($key, $val) use ($foo) { /* ... */ },
    array(key1 => val1,
          key2 => val2,
          /* ... */));

अप्रत्यक्ष एरे वॉक

ऊपर लिखते समय मैंने array_walk को नजरअंदाज कर दिया था क्योंकि इसे इसके तर्क को संदर्भ द्वारा पारित करने की आवश्यकता है; हालाँकि, मैंने महसूस किया है कि call_user_func का उपयोग करके इसके आसपास काम करना आसान है। मुझे लगता है कि यह अब तक का सबसे अच्छा संस्करण है:

call_user_func(
    'array_walk',
    array(key1 => val1,
          key2 => val2,
          /* ... */),
    function($val, $key) use ($foo) { /* ... */ });

Answer 3

बहुत आसान:

केवल array_map fuction: इसमें इंडेक्स की नहीं है!

 $params = [4,6,2,11,20];

 $data = array_map(function($v) { return ":id{$v}";}, $params);

 array (size=5)
  0 => string ':id4' (length=4)
  1 => string ':id6' (length=4)
  2 => string ':id2' (length=4)
  3 => string ':id11' (length=5)
  4 => string ':id20' (length=5)

अब, array_keys के साथ संयोजन करें:

$data = array_map(
    function($k) use ($params) { return ":id{$k}_${params[$k]}"; },
    array_keys($params)
 );

array (size=5)
  0 => string ':id0_4' (length=6)
  1 => string ':id1_6' (length=6)
  2 => string ':id2_2' (length=6)
  3 => string ':id3_11' (length=7)
  4 => string ':id4_20' (length=7)

Answer 4

आप अपना स्वयं का मानचित्र कार्य बना सकते हैं foreach:

<?php

function myCallback($key, $val)
{
    var_dump("myCallback - key: $key, val: $val");
    return $val * 2;
}

function foreachMap($callback, $givenArray) {
    $result = [];
    foreach ($givenArray as $key=>$val) {
        $result[$key] = $callback($key, $val);
    }
    return $result;
}

$values = array(4, 6, 3);
$mapped = foreachMap('myCallback', $values);
var_dump($mapped);

कोशिश करें: https://3v4l.org/pmFlB