Böyle bir şey yapmanın bir yolu var mı:

$test_array = array("first_key" => "first_value", 
                    "second_key" => "second_value");

var_dump(array_map(function($a, $b) { return "$a loves $b"; }, 
         array_keys($test_array), 
         array_values($test_array)));

Ama bunun yerine çağıran array_keysve array_valuesdoğrudan geçirerek, $test_arraydeğişken?

İstenen çıktı:

array(2) {
  [0]=>
  string(27) "first_key loves first_value"
  [1]=>
  string(29) "second_key loves second_value"
}

Anahtarları işlemediğinden array_map ile değil.

array_walk şunları yapar:

$test_array = array("first_key" => "first_value",
                    "second_key" => "second_value");
array_walk($test_array, function(&$a, $b) { $a = "$b loves $a"; });
var_dump($test_array);

// array(2) {
//   ["first_key"]=>
//   string(27) "first_key loves first_value"
//   ["second_key"]=>
//   string(29) "second_key loves second_value"
// }

Bununla birlikte, parametre olarak verilen diziyi değiştirir, bu yüzden tam olarak işlevsel programlama değildir (bu şekilde etiketlenmiş sorunuz olduğu gibi). Ayrıca, yorumda belirtildiği gibi, bu yalnızca dizinin değerlerini değiştirir, böylece anahtarlar soruda belirttiğiniz gibi olmaz.

İsterseniz yukarıdaki noktaları kendiniz sabitleyen bir işlev yazabilirsiniz, şöyle:

function mymapper($arrayparam, $valuecallback) {
  $resultarr = array();
  foreach ($arrayparam as $key => $value) {
    $resultarr[] = $valuecallback($key, $value);
  }
  return $resultarr;
}

$test_array = array("first_key" => "first_value",
                    "second_key" => "second_value");
$new_array = mymapper($test_array, function($a, $b) { return "$a loves $b"; });
var_dump($new_array);

// array(2) {
//   [0]=>
//   string(27) "first_key loves first_value"
//   [1]=>
//   string(29) "second_key loves second_value"
// }

Muhtemelen en kısa ve en kolay mantık şudur:

$states = array('az' => 'Arizona', 'al' => 'Alabama');

array_map(function ($short, $long) {
    return array(
        'short' => $short,
        'long'  => $long
    );
}, array_keys($states), $states);

// produces:
array(
     array('short' => 'az', 'long' => 'Arizona'), 
     array('short' => 'al', 'long' => 'Alabama')
)

İşte benim çok basit, PHP 5.5 uyumlu çözümüm:

function array_map_assoc(callable $f, array $a) {
    return array_column(array_map($f, array_keys($a), $a), 1, 0);
}

Sağladığınız çağrılabilirin kendisi iki değere sahip bir dizi döndürmelidir return [key, value]. Bu array_mapnedenle iç çağrı , bir dizi dizi üretir. Bu daha sonra tarafından tek boyutlu bir diziye geri dönüştürülür array_column.

kullanım

$ordinals = [
    'first' => '1st',
    'second' => '2nd',
    'third' => '3rd',
];

$func = function ($k, $v) {
    return ['new ' . $k, 'new ' . $v];
};

var_dump(array_map_assoc($func, $ordinals));

Çıktı

array(3) {
  ["new first"]=>
  string(7) "new 1st"
  ["new second"]=>
  string(7) "new 2nd"
  ["new third"]=>
  string(7) "new 3rd"
}

Kısmi uygulama

İşlevi farklı dizilerle ancak aynı eşleme işleviyle birçok kez kullanmanız gerekirse, yalnızca çağırma üzerine veri dizisine geçmenize izin veren kısmi işlev uygulaması (' currying ' ile ilgili) olarak adlandırılan bir şey yapabilirsiniz :

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

Hangi aynı çıktıyı verir, verilen $funcve $ordinalsdaha önceki gibi.

NOT: eşlenen işleviniz iki farklı giriş için aynı anahtarı döndürürse , sonraki anahtarla ilişkili değer kazanacaktır. array_map_assocDaha önceki anahtarların kazanmasına izin vermek için giriş dizisini ve çıkış sonucunu tersine çevirin . (Örneğimdeki döndürülen anahtarlar, kaynak dizinin anahtarını içerdiklerinden çakışamazlar; bu da benzersiz olmalıdır.)

Alternatif

Aşağıda, bazıları için daha mantıklı olabilecek, ancak PHP 5.6 gerektiren bir varyant yer almaktadır:

function array_map_assoc(callable $f, array $a) {
    return array_merge(...array_map($f, array_keys($a), $a));
}

Bu varyantta, sağladığınız işlev (üzerinde veri dizisinin eşlendiği), bunun yerine bir satırla ilişkilendirilebilir bir dizi döndürmelidir return [key => value]. Çağrılabilir eşlemenin sonucu daha sonra paketten çıkarılır ve iletilir array_merge. Daha önce olduğu gibi, yinelenen bir anahtarın döndürülmesi sonraki değerlerin kazanılmasına neden olacaktır.

nb Alex83690 bir yorumda, array_replacebunun yerine burada array_mergetamsayı anahtarlarının korunacağını belirtti. array_replacegiriş dizisini değiştirmez, bu nedenle işlevsel kod için güvenlidir.

PHP 5.3 ile 5.5 arasındaysanız, aşağıdakine denktir. Anahtarları korurken elde edilen iki boyutlu diziyi tek boyutlu bir diziye dönüştürmek için array_reduceve ikili +dizi operatörünü kullanır :

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;
    }, []);
}

kullanım

Bu değişkenlerin her ikisi de şu şekilde kullanılır:

$ordinals = [
    'first' => '1st',
    'second' => '2nd',
    'third' => '3rd',
];

$func = function ($k, $v) {
    return ['new ' . $k => 'new ' . $v];
};

var_dump(array_map_assoc($func, $ordinals));

Not =>yerine ,de $func.

Çıktı öncekiyle aynıdır ve her biri eskisi gibi kısmen uygulanabilir.

 özet

Orijinal sorunun amacı, çağrının çağrılmasını mümkün olduğunca basit hale getirmek ve çağrılmış daha karmaşık bir işleve sahip olmaktır; özellikle, veri dizisini anahtarları ve değerleri bölmeden tek bir argüman olarak iletme yeteneğine sahip olmak. Bu cevabın başında verilen işlevi kullanarak:

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

Veya yalnızca bu soru için, array_map_assoc()çıkış anahtarları bırakan işlev için basitleştirme yapabiliriz , çünkü soru bunları sormaz:

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

Yani cevap HAYIR , aramaktan kaçınamazsınız array_keys, ancak array_keysyeterince iyi olabilecek daha üst düzey bir fonksiyona çağrılan yeri soyutlayabilirsiniz .

PHP5.3 veya üstü ile:

$test_array = array("first_key" => "first_value", 
                    "second_key" => "second_value");

var_dump(
    array_map(
        function($key) use ($test_array) { return "$key loves ${test_array[$key]}"; },
        array_keys($test_array)
    )
);

Bunu projemde böyle uyguladım.

function array_map_associative(callable $callback, $array) {
    /* map original array keys, and call $callable with $key and value of $key from original array. */
    return array_map(function($key) use ($callback, $array){
        return $callback($key, $array[$key]);
    }, array_keys($array));
}

Buraya bak! Önemsiz bir çözüm var!

function array_map2(callable $f, array $a)
{
    return array_map($f, array_keys($a), $a);
}

Soruda belirtildiği gibi, array_map zaten gerekli işlevselliğe zaten sahiptir . Buradaki diğer cevaplar şeyleri ciddi şekilde aşırı karmaşıklaştırıyor: array_walkişlevsel değil.

kullanım

Tam olarak örneğin beklediğiniz gibi:

$test_array = array("first_key" => "first_value", 
                    "second_key" => "second_value");

var_dump(array_map2(function($a, $b) { return "$a loves $b"; }, $test_array));

$array = [
  'category1' => 'first category',
  'category2' => 'second category',
];

$new = array_map(function($key, $value) {
  return "{$key} => {$value}";
}, array_keys($array), $array);

Kaynak

"El ile döngü" derken kullanan özel bir işlev yazmak istedim foreach. Bu array_map, işlevi gibi yeni bir dizi döndürür , çünkü işlevin kapsamı $arraybir referans değil kopyaya neden olur :

function map($array, callable $fn) {
  foreach ($array as $k => &$v) $v = call_user_func($fn, $k, $v);
  return $array;
}

Bununla array_mapbirlikte kullanma tekniğiniz array_keysaslında daha basit görünüyor ve daha güçlü çünkü nullanahtar / değer çiftlerini döndürmek için geri arama olarak kullanabilirsiniz :

function map($array, callable $fn = null) {
  return array_map($fn, array_keys($array), $array);
}

Eis'in cevabına dayanarak, sonunda orijinal diziyi karıştırmamak için ne yaptım:

$test_array = array("first_key" => "first_value",
                    "second_key" => "second_value");

$result_array = array();
array_walk($test_array, 
           function($a, $b) use (&$result_array) 
           { $result_array[] = "$b loves $a"; }, 
           $result_array);
var_dump($result_array);

Bu işlevi, eis'in cevabına dayanarak yaptım :

function array_map_($callback, $arr) {
    if (!is_callable($callback))
        return $arr;

    $result = array_walk($arr, function(&$value, $key) use ($callback) {
        $value = call_user_func($callback, $key, $value);
    });

    if (!$result)
        return false;

    return $arr;
}

Misal:

$test_array = array("first_key" => "first_value", 
                "second_key" => "second_value");

var_dump(array_map_(function($key, $value){
    return $key . " loves " . $value;
}, $arr));

Çıktı:

array (
  'first_key' => 'first_key loves first_value,
  'second_key' => 'second_key loves second_value',
)

Elbette, array_valuesOP'nin tam olarak istediği şeyi döndürmek için kullanabilirsiniz .

array_values(array_map_(function($key, $value){
    return $key . " loves " . $value;
}, $test_array))

YaLinqo kütüphanesi * bu tür görevler için çok uygundur. Tüm geri aramalarda değerleri ve anahtarları tam olarak destekleyen ve SQL'e benzeyen .NET LINQ bağlantı noktasıdır. Örneğin:

$mapped_array = from($test_array)
    ->select(function ($v, $k) { return "$k loves $v"; })
    ->toArray();

ya da sadece:

$mapped_iterator = from($test_array)->select('"$k loves $v"');

Burada, '"$k loves $v"'bu kitaplığın desteklediği tam kapatma sözdizimi için bir kısayoldur. toArray()sonunda isteğe bağlıdır. Yöntem zincir sonucu sadece kullanarak iterated gereken Öyleyse, bir yineleyici döndürür foreach, toArrayçağrı çıkarılabilir.

_{* benim tarafımdan geliştirildi}

Böyle bir şey yapardım:

<?php

/**
 * array_map_kv()
 *   An array mapping function to map with both keys and values.
 *
 * @param $callback callable
 *   A callback function($key, $value) for mapping values.
 * @param $array array
 *   An array for mapping.
 */
function array_map_kv(callable $callback, array $array) {
  return array_map(
    function ($key) use ($callback, $array) {
      return $callback($key, $array[$key]); // $callback($key, $value)
    },
    array_keys($array)
  );
}

// use it
var_dump(array_map_kv(function ($key, $value) {
  return "{$key} loves {$value}";
}, array(
  "first_key" => "first_value",
  "second_key" => "second_value",
)));

?>

Sonuçlar:

array(2) {
  [0]=>
  string(27) "first_key loves first_value"
  [1]=>
  string(29) "second_key loves second_value"
}

Sürüm 5.6 veya üstünü kullanarak soruna başka bir çözüm daha ekleyeceğim. Zaten harika çözümlerden (muhtemelen değil) daha verimli olup olmadığını bilmiyorum, ama bana göre sadece okumak daha basit:

$myArray = [
    "key0" => 0,
    "key1" => 1,
    "key2" => 2
];

array_combine(
    array_keys($myArray),
    array_map(
        function ($intVal) {
            return strval($intVal);
        },
        $myArray
    )
);

strval()Bir örnek işlev olarak kullanarak array_map, bu üretecektir:

array(3) {
  ["key0"]=>
  string(1) "0"
  ["key1"]=>
  string(1) "1"
  ["key2"]=>
  string(1) "2"
}

Umarım bunu kavramak için oldukça basit olan tek kişi ben değilim. array_combinebir key => valuedizi anahtardan ve bir değer dizisinden bir dizi oluşturur, geri kalanı oldukça açıklayıcıdır.

Tam olarak ne istediğinizi elde etmek için bu dizi kitaplığındaki harita yöntemini kullanabilirsiniz :

Arr::map($test_array, function($a, $b) { return "$a loves $b"; });

ayrıca anahtarlarınızı korur ve ihtiyaçlarınıza uygun birkaç farklı moddan bahsetmeden yeni bir dizi döndürür.

Her zaman dizi haritasının javascript varyantını seviyorum. Bunun en basit versiyonu:

/**
 * @param  array    $array
 * @param  callable $callback
 * @return array
 */
function arrayMap(array $array, callable $callback)
{
    $newArray = [];

    foreach( $array as $key => $value )
    {
        $newArray[] = call_user_func($callback, $value, $key, $array);
    }

    return $newArray;
}

Böylece şimdi sadece değerleri nasıl oluşturacağınız bir geri arama fonksiyonu iletebilirsiniz.

$testArray = [
    "first_key" => "first_value", 
    "second_key" => "second_value"
];

var_dump(
    arrayMap($testArray, function($value, $key) {
        return $key . ' loves ' . $value;
    });
);

Bunu anahtarları koruyarak (dışarı) yapmanın başka bir yolu:

$test_array = [
    "first_key"     => "first_value",
    "second_key"    => "second_value"
];

$f = function($ar) {
    return array_map(
        function($key, $val) {
            return "{$key} - {$val}";
        },
        array_keys($ar),
        $ar
    );
};

#-- WITHOUT preserving keys
$res = $f($test_array);

#-- WITH preserving keys
$res = array_combine(
    array_keys($test_array),
    $f($test_array)
);

Açık cevabın eksik olduğunu görüyorum:

function array_map_assoc(){
    if(func_num_args() < 2) throw new \BadFuncionCallException('Missing parameters');

    $args = func_get_args();
    $callback = $args[0];

    if(!is_callable($callback)) throw new \InvalidArgumentException('First parameter musst be callable');

    $arrays = array_slice($args, 1);

    array_walk($arrays, function(&$a){
        $a = (array)$a;
        reset($a);
    });

    $results = array();
    $max_length = max(array_map('count', $arrays));

    $arrays = array_map(function($pole) use ($max_length){
        return array_pad($pole, $max_length, null);
    }, $arrays);

    for($i=0; $i < $max_length; $i++){
        $elements = array();
        foreach($arrays as &$v){
            $elements[] = each($v);
        }
        unset($v);

        $out = call_user_func_array($callback, $elements);

        if($out === null) continue;

        $val = isset($out[1]) ? $out[1] : null;

        if(isset($out[0])){
            $results[$out[0]] = $val;
        }else{
            $results[] = $val;
        }
    }

    return $results;
}

Tam olarak array_map gibi çalışır. Neredeyse.

Aslında, mapdiğer dillerden bildiğiniz gibi saf değil . Php çok garip, bu yüzden bazı çok garip kullanıcı fonksiyonları gerektirir, çünkü biz kesinlikle kırık worse is betteryaklaşımımızı kırmak istemiyoruz .

Gerçekten, aslında maphiç de değil . Yine de, hala çok faydalı.

• Array_map ile ilgili ilk belirgin fark, geri çağrının each()tek başına değer yerine her girdi dizisinden çıktı almasıdır . Aynı anda daha fazla diziyi yineleyebilirsiniz.

• İkinci fark, geri aramadan döndükten sonra anahtarın ele alınma şeklidir; geri arama işlevinden döndürülen değer olmalıdır array('new_key', 'new_value'). Anahtarlar değiştirilebilir ve değiştirilecektir, aynı anahtarlar döndürülmüşse, aynı anahtarlar önceki değerin üzerine yazılmasına neden olabilir. Bu yaygın bir mapdavranış değildir , ancak anahtarları yeniden yazmanıza izin verir.

• Üçüncü garip şey, keydönüş değerini ( array(1 => 'value')veya ile array(null, 'value')) atlarsanız $array[] = $value, kullanılmış gibi yeni anahtar atanacaktır . Bu da maportak bir davranış değil, ama bazen kullanışlı geliyor sanırım.

• Dördüncü garip şey, geri arama işlevi bir değer döndürmezse veya geri dönerse null, geçerli anahtarların ve değerlerin tümünün çıktıdan çıkarılması, basitçe atlanmasıdır. Bu özellik tamamen un mappy, ancak böyle bir işlev olsaydı, bu işlevi mükemmel dublör çift yapardı array_filter_assoc.

• Geri aramanın geri dönüşünde ikinci elemanı ( 1 => ...) ( değer kısmı) atlarsanız null, gerçek değer yerine kullanılır.

• Anahtarları 0ve 1geri aramanın geri dönüşü dışında olanlar dışındaki tüm öğeler yok sayılır.

• Ve son olarak, lambda nullveya dizi dışında herhangi bir değer döndürürse , hem anahtar hem de değer atlanmış gibi ele alınır, bu nedenle:

  1. öğe için yeni anahtar atandı
  2. null değeri olarak kullanılır

UYARI:
Bu son özelliğin yalnızca önceki özelliklerin bir kalıntısı olduğunu ve muhtemelen tamamen yararsız olduğunu unutmayın. Bu özelliğe güvenmek son derece cesaret kırıcıdır, çünkü bu özellik gelecekteki sürümlerde rasgele kullanımdan kaldırılacak ve beklenmedik bir şekilde değişecektir.

Not: içinde
aksine , ilk geri arama parametresi dışında array_mapgeçirilen tüm dizi olmayan array_map_assocparametreler sessizce dizilere dökülür.

ÖRNEKLER:
// TODO: examples, anyone?