Apakah ada cara melakukan sesuatu seperti ini:

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

Tapi bukannya memanggil array_keysdan array_values, langsung melewati $test_arrayvariabel?

Output yang diinginkan adalah:

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

Tidak dengan array_map, karena tidak menangani kunci.

array_walk tidak:

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

Itu memang mengubah array yang diberikan sebagai parameter, jadi itu bukan pemrograman fungsional (karena Anda memiliki pertanyaan yang ditandai seperti itu). Juga, seperti yang ditunjukkan dalam komentar, ini hanya akan mengubah nilai-nilai array, jadi kunci tidak akan menjadi apa yang Anda tentukan dalam pertanyaan.

Anda bisa menulis fungsi yang memperbaiki poin-poin di atas sendiri jika Anda mau, seperti ini:

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"
// }

Ini mungkin yang terpendek dan termudah untuk dipikirkan:

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

Inilah solusi PHP 5.5-kompatibel saya yang sangat sederhana:

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

Callable yang Anda berikan harus mengembalikan array dengan dua nilai, yaitu return [key, value]. Karena itu panggilan batin untuk array_mapmenghasilkan array array. Ini kemudian akan dikonversi kembali ke array dimensi tunggal oleh array_column.

Pemakaian

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

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

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

Keluaran

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

Aplikasi sebagian

Jika Anda perlu menggunakan fungsi berkali-kali dengan array yang berbeda tetapi fungsi pemetaan yang sama, Anda bisa melakukan sesuatu yang disebut aplikasi fungsi parsial (terkait dengan ' currying '), yang memungkinkan Anda untuk hanya memasukkan array data setelah doa:

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

Yang menghasilkan output yang sama, diberikan $funcdan $ordinalssama seperti sebelumnya.

CATATAN: jika fungsi Anda yang dipetakan mengembalikan kunci yang sama untuk dua input berbeda, nilai yang terkait dengan kunci nanti akan menang. Membalikkan array input dan hasil output array_map_assocuntuk memungkinkan kunci sebelumnya untuk menang. (Kunci yang dikembalikan dalam contoh saya tidak dapat bertabrakan karena mereka memasukkan kunci dari array sumber, yang pada gilirannya harus unik.)

Alternatif

Berikut ini adalah varian di atas, yang mungkin terbukti lebih logis untuk beberapa orang, tetapi membutuhkan PHP 5.6:

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

Dalam varian ini, fungsi yang disediakan Anda (di mana array data dipetakan) akan mengembalikan array asosiatif dengan satu baris, yaitu return [key => value]. Hasil pemetaan callable kemudian dibongkar dan diteruskan ke array_merge. Seperti sebelumnya, mengembalikan kunci duplikat akan menghasilkan nilai yang menang kemudian.

nb Alex83690 telah mencatat dalam komentar bahwa menggunakan array_replacedi sini sebagai pengganti array_mergeakan mempertahankan kunci integer. array_replacetidak memodifikasi array input, jadi aman untuk kode fungsional.

Jika Anda menggunakan PHP 5.3 hingga 5.5, yang berikut ini setara. Ini menggunakan array_reducedan +operator array biner untuk mengkonversi array dua dimensi yang dihasilkan ke array satu dimensi sambil mempertahankan kunci:

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

Pemakaian

Kedua varian ini akan digunakan sebagai berikut:

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

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

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

Perhatikan =>bukan ,di $func.

Outputnya sama seperti sebelumnya, dan masing-masing dapat diterapkan sebagian dengan cara yang sama seperti sebelumnya.

 Ringkasan

Tujuan dari pertanyaan awal adalah untuk membuat doa panggilan sesederhana mungkin, dengan mengorbankan fungsi yang lebih rumit yang dipanggil; khususnya, untuk memiliki kemampuan untuk melewatkan array data sebagai argumen tunggal, tanpa memisahkan kunci dan nilai. Menggunakan fungsi yang disediakan di awal jawaban ini:

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

Atau, hanya untuk pertanyaan ini, kita dapat menyederhanakan array_map_assoc()fungsi yang menjatuhkan kunci output, karena pertanyaan tidak menanyakannya:

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

Jadi jawabannya adalah TIDAK , Anda tidak bisa menghindari panggilan array_keys, tetapi Anda bisa mengabstraksikan tempat di mana array_keysdipanggil menjadi fungsi tingkat tinggi, yang mungkin cukup baik.

Dengan PHP5.3 atau lebih baru:

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

Ini adalah bagaimana saya menerapkan ini dalam proyek saya.

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

Lihat di sini! Ada solusi sepele!

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

Sebagaimana dinyatakan dalam pertanyaan, array_map sudah persis fungsionalitas yang diperlukan . Jawaban lain di sini serius hal rumit: array_walktidak berfungsi.

Pemakaian

Persis seperti yang Anda harapkan dari contoh Anda:

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

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

Dengan "loop manual" yang saya maksud menulis fungsi kustom yang menggunakan foreach. Ini mengembalikan array baru seperti yang array_mapdilakukan karena ruang lingkup fungsi menyebabkan $arraysalinan — bukan referensi:

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

Teknik Anda menggunakan array_mapdengan array_keysmeskipun sebenarnya tampak lebih sederhana dan lebih kuat karena Anda dapat menggunakan nullsebagai panggilan balik untuk mengembalikan pasangan nilai kunci:

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

Berdasarkan jawaban eis , inilah yang akhirnya saya lakukan untuk menghindari mengacaukan array asli:

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

Saya membuat fungsi ini, berdasarkan jawaban eis :

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

Contoh:

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

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

Keluaran:

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

Tentu saja, Anda dapat menggunakan array_valuesuntuk mengembalikan persis apa yang diinginkan OP.

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

Pustaka YaLinqo * sangat cocok untuk tugas semacam ini. Ini adalah port LINQ dari. NET yang sepenuhnya mendukung nilai dan kunci di semua panggilan balik dan menyerupai SQL. Sebagai contoh:

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

atau hanya:

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

Di sini, '"$k loves $v"'adalah jalan pintas untuk sintaksis penutupan penuh yang didukung perpustakaan ini. toArray()pada akhirnya adalah opsional. Rantai metode mengembalikan sebuah iterator, jadi jika hasilnya hanya perlu diulangi menggunakan foreach, toArraypanggilan dapat dihapus.

_{* Dikembangkan oleh saya}

Saya akan melakukan sesuatu seperti ini:

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

?>

Hasil:

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

Saya akan menambahkan solusi lain untuk masalah menggunakan versi 5.6 atau yang lebih baru. Tidak tahu apakah ini lebih efisien daripada solusi yang sudah bagus (mungkin tidak), tetapi bagi saya itu lebih mudah dibaca:

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

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

Menggunakan strval()sebagai contoh fungsi dalam array_map, ini akan menghasilkan:

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

Semoga saya bukan satu-satunya yang menemukan ini cukup mudah untuk dipahami. array_combinemenciptakan key => valuearray dari array kunci dan array nilai, sisanya cukup jelas.

Anda dapat menggunakan metode peta dari pustaka array ini untuk mencapai apa yang Anda inginkan semudah:

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

juga mempertahankan kunci dan mengembalikan array baru, belum lagi beberapa mode yang berbeda sesuai dengan kebutuhan Anda.

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

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

Sumber

Saya selalu suka varian javascript dari array map. Versi paling sederhana adalah:

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

Jadi sekarang Anda bisa meneruskannya fungsi callback bagaimana membangun nilai-nilai.

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

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

Cara lain untuk melakukan ini dengan melestarikan kunci:

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

Saya melihat itu kehilangan jawaban yang jelas:

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

Bekerja persis seperti array_map. Hampir.

Sebenarnya, itu tidak murni mapseperti yang Anda tahu dari bahasa lain. Php sangat aneh, jadi itu memerlukan beberapa fungsi pengguna yang sangat aneh, karena kami tidak ingin membatalkan worse is betterpendekatan kami yang rusak .

Sungguh, sebenarnya tidak mapsama sekali. Namun, itu masih sangat berguna.

• Perbedaan pertama yang jelas dari array_map, adalah bahwa callback mengambil output each()dari setiap input array bukan hanya nilai. Anda masih dapat melakukan iterasi melalui lebih banyak array sekaligus.

• Perbedaan kedua adalah cara kunci ditangani setelah dikembalikan dari panggilan balik; nilai balik dari fungsi panggilan balik seharusnya array('new_key', 'new_value'). Kunci dapat dan akan diubah, kunci yang sama bahkan dapat menyebabkan nilai sebelumnya ditimpa, jika kunci yang sama dikembalikan. Ini bukan mapperilaku umum , namun memungkinkan Anda untuk menulis ulang kunci.

• Hal aneh ketiga adalah, jika Anda menghilangkan keynilai balik (baik oleh array(1 => 'value')atau array(null, 'value')), kunci baru akan ditetapkan, seolah-olah $array[] = $valuedigunakan. Itu juga bukan mapperilaku umum, namun terkadang berguna, saya kira.

• Keanehan keempat adalah, jika fungsi callback tidak mengembalikan nilai, atau mengembalikan null, seluruh rangkaian kunci dan nilai saat ini dihilangkan dari output, itu hanya dilewati. Fitur ini benar-benar un mappy, namun itu akan membuat fungsi ini berfungsi sangat baik untuk ganda array_filter_assoc, jika ada fungsi seperti itu.

• Jika Anda menghilangkan elemen kedua ( 1 => ...) (bagian nilai ) dalam pengembalian panggilan balik, nulldigunakan sebagai ganti nilai sebenarnya.

• Elemen lain apa pun kecuali yang memiliki kunci 0dan 1sebagai balasannya kembali diabaikan.

• Dan akhirnya, jika lambda mengembalikan nilai apa pun kecuali nullatau array, itu diperlakukan seolah-olah kedua kunci dan nilai dihilangkan, jadi:

  1. kunci baru untuk elemen ditugaskan
  2. null digunakan sebagai nilainya

PERINGATAN:
Ingatlah, bahwa fitur terakhir ini hanyalah residu dari fitur sebelumnya dan mungkin sama sekali tidak berguna. Mengandalkan fitur ini sangat tidak dianjurkan, karena fitur ini akan ditinggalkan secara acak dan diubah secara tak terduga dalam rilis mendatang.

CATATAN:
Tidak seperti di array_map, semua parameter non-array yang diteruskan ke array_map_assoc, dengan pengecualian parameter panggilan balik pertama, secara diam-diam dicor ke array.

CONTOH:
// TODO: examples, anyone?