Czy istnieje sposób na zrobienie czegoś takiego:

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

Ale zamiast wywoływać array_keysi array_valuesbezpośrednio przekazywać $test_arrayzmienną?

Pożądane wyjście to:

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

Nie z array_map, ponieważ nie obsługuje kluczy.

array_walk robi:

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

Zmienia jednak tablicę podaną jako parametr, więc nie jest to do końca funkcjonalne programowanie (ponieważ masz tak oznaczone pytanie). Ponadto, jak wskazano w komentarzu, spowoduje to jedynie zmianę wartości tablicy, więc klucze nie będą zgodne z danymi podanymi w pytaniu.

Jeśli chcesz, możesz napisać funkcję, która naprawia punkty powyżej.

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

Jest to prawdopodobnie najkrótszy i najłatwiejszy do uzasadnienia temat:

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

Oto moje bardzo proste rozwiązanie kompatybilne z PHP 5.5:

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

Podane przez Ciebie wywołanie powinno zwrócić tablicę z dwiema wartościami, tj return [key, value]. Wewnętrzne wezwanie do array_maptworzy zatem tablicę tablic. To następnie jest konwertowane z powrotem do tablicy jednowymiarowej przez array_column.

Stosowanie

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

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

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

Wynik

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

Częściowe zastosowanie

W przypadku, gdy trzeba używać tej funkcji wiele razy z różnymi tablicami, ale z tą samą funkcją mapowania, można zrobić coś, co nazywa się aplikacją funkcji częściowej (związaną z „ curry ”), co pozwala na przekazanie tablicy danych tylko po wywołaniu:

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

Który daje taką samą wydajność, podaną $funci $ordinalssą jak wcześniej.

UWAGA: jeśli funkcja zamapowana zwraca ten sam klucz dla dwóch różnych danych wejściowych, wartość powiązana z późniejszym kluczem wygra. Odwróć tablicę wejściową i wynik wyjściowy, array_map_assocaby umożliwić wygrywanie wcześniejszym kluczom. (Zwrócone klucze w moim przykładzie nie mogą kolidować, ponieważ zawierają klucz tablicy źródłowej, która z kolei musi być unikalna).

Alternatywny

Poniżej przedstawiono wariant powyższego, który dla niektórych może okazać się bardziej logiczny, ale wymaga PHP 5.6:

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

W tym wariancie podana funkcja (na której odwzorowana jest tablica danych) powinna zamiast tego zwrócić tablicę asocjacyjną z jednym wierszem, tj return [key => value]. Wynik mapowania wywoływanego elementu jest następnie po prostu rozpakowywany i przekazywany do array_merge. Tak jak wcześniej, zwrócenie duplikatu klucza spowoduje wygraną późniejszych wartości.

nb Alex83690 zauważył w komentarzu, że użycie array_replacetutaj w miejsce array_mergezachowałoby klucze do liczb całkowitych. array_replacenie modyfikuje tablicy wejściowej, więc jest bezpieczny dla kodu funkcjonalnego.

Jeśli korzystasz z PHP 5.3 do 5.5, poniższe są równoważne. Wykorzystuje array_reducei +operator tablicy binarnej do konwersji wynikowej tablicy dwuwymiarowej na tablicę jednowymiarową przy jednoczesnym zachowaniu kluczy:

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

Stosowanie

Oba te warianty zostałyby wykorzystane w ten sposób:

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

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

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

Uwaga =>zamiast ,w $func.

Dane wyjściowe są takie same jak poprzednio i każdy może być częściowo zastosowany w taki sam sposób jak poprzednio.

 Podsumowanie

Pierwotne pytanie ma na celu uproszczenie wywołania wywołania kosztem posiadania bardziej skomplikowanej funkcji, która zostanie wywołana; szczególnie, aby mieć możliwość przekazania tablicy danych jako jednego argumentu, bez dzielenia kluczy i wartości. Korzystanie z funkcji dostarczonej na początku tej odpowiedzi:

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

Lub, tylko dla tego pytania, możemy uprościć array_map_assoc()funkcję, która upuszcza klucze wyjściowe, ponieważ pytanie nie wymaga ich:

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

Tak więc odpowiedź brzmi NIE , nie można uniknąć dzwonienia array_keys, ale można wykreślić miejsce, w którym array_keyswywoływana jest funkcja wyższego rzędu, co może być wystarczająco dobre.

W wersji PHP 5.3 lub nowszej:

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

Tak zaimplementowałem to w moim projekcie.

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

Popatrz tutaj! Istnieje trywialne rozwiązanie!

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

Jak stwierdzono w pytaniu, array_map ma już dokładnie wymaganą funkcjonalność . Inne odpowiedzi tutaj poważnie komplikują: array_walknie działa.

Stosowanie

Dokładnie tak, jak można oczekiwać po swoim przykładzie:

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

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

Przez „ręczną pętlę” miałem na myśli napisanie niestandardowej funkcji, która używa foreach. Zwraca to nową tablicę, podobnie jak array_maprobi, ponieważ zasięg funkcji powoduje, $arrayże jest to kopia, a nie odwołanie:

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

Twoja technika używania array_mapz array_keyschociaż wydaje się być prostsza i bardziej wydajna, ponieważ możesz użyć nulljako wywołania zwrotnego, aby zwrócić pary klucz-wartość:

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

W oparciu o odpowiedź eis , oto co ostatecznie zrobiłem, aby uniknąć bałaganu w oryginalnej tablicy:

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

Zrobiłem tę funkcję na podstawie odpowiedzi 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;
}

Przykład:

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

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

Wynik:

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

Oczywiście możesz użyć, array_valuesaby zwrócić dokładnie to, czego chce OP.

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

Biblioteka YaLinqo * dobrze nadaje się do tego rodzaju zadań. Jest to port LINQ z .NET, który w pełni obsługuje wartości i klucze we wszystkich wywołaniach zwrotnych i przypomina SQL. Na przykład:

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

Lub tylko:

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

Oto '"$k loves $v"'skrót do składni pełnego zamknięcia obsługiwanej przez tę bibliotekę. toArray()w końcu jest opcjonalny. Łańcuch metod zwraca iterator, więc jeśli wynik wymaga tylko iteracji za pomocą foreach, toArraywywołanie można usunąć.

_{* opracowane przeze mnie}

Zrobiłbym coś takiego:

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

?>

Wyniki:

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

Dodam jeszcze jedno rozwiązanie problemu przy użyciu wersji 5.6 lub nowszej. Nie wiem, czy jest bardziej wydajny niż i tak już świetne rozwiązania (prawdopodobnie nie), ale dla mnie jest po prostu łatwiej czytać:

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

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

Używając strval()jako przykładowej funkcji w array_map, wygeneruje:

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

Mam nadzieję, że nie tylko ja uważam to za dość proste. array_combinetworzy key => valuetablicę z tablicy kluczy i tablicy wartości, reszta jest dość oczywista.

Możesz użyć metody mapowania z tej biblioteki tablic, aby osiągnąć dokładnie to, czego chcesz tak łatwo, jak:

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

zachowuje również klucze i zwraca nową tablicę, nie wspominając o kilku różnych trybach, które pasują do twoich potrzeb.

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

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

Źródło

Zawsze lubię javascriptowy wariant mapy tablic. Najprostsza wersja to:

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

Teraz możesz przekazać funkcję wywołania zwrotnego, jak skonstruować wartości.

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

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

Inny sposób na zrobienie tego z (poza) zachowaniem kluczy:

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

Widzę, że brakuje oczywistej odpowiedzi:

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

Działa dokładnie tak, jak array_map. Prawie.

W rzeczywistości nie jest tak czysty, mapjak znasz go z innych języków. Php jest bardzo dziwny, dlatego wymaga bardzo dziwnych funkcji użytkownika, ponieważ nie chcemy zerwać z naszym dokładnie zepsutym worse is betterpodejściem.

Naprawdę wcale tak nie jest map. Jednak nadal jest bardzo przydatny.

• Pierwszą oczywistą różnicą od array_map jest to, że callback pobiera dane wyjściowe each()z każdej tablicy wejściowej zamiast samej wartości. Nadal możesz iterować więcej tablic jednocześnie.

• Druga różnica polega na sposobie obsługi klucza po jego zwróceniu z wywołania zwrotnego; wartość zwracana z funkcji zwrotnej powinna wynosić array('new_key', 'new_value'). Klucze można i będą zmieniane, te same klucze mogą nawet spowodować zastąpienie poprzedniej wartości, jeśli ten sam klucz został zwrócony. To nie jest powszechne mapzachowanie, ale pozwala przepisać klucze.

• Trzecią dziwną rzeczą jest to, że jeśli pominiesz keywartość zwracaną (przez array(1 => 'value')lub array(null, 'value')), zostanie przypisany nowy klucz, tak jakby $array[] = $valuezostał użyty. To też nie mapjest powszechne zachowanie, ale wydaje mi się, że czasem przydaje się.

• Czwarta dziwna rzecz: jeśli funkcja zwrotna nie zwraca wartości lub zwraca null, cały zestaw bieżących kluczy i wartości jest pomijany na wyjściu, jest po prostu pomijany. Ta funkcja jest całkowicie mapniedostępna, ale sprawiłaby, że ta funkcja byłaby doskonała dla kaskaderów array_filter_assoc, gdyby była taka funkcja.

• Jeśli pominiesz drugi element ( 1 => ...) ( część wartości ) w zwrocie wywołania zwrotnego, nullzostanie użyty zamiast wartości rzeczywistej.

• Wszelkie inne elementy oprócz tych z kluczami 0i 1po oddzwonieniu są ignorowane.

• I na koniec, jeśli lambda zwraca dowolną wartość oprócz nulllub tablicę, jest to traktowane tak, jakby pominięto zarówno klucz, jak i wartość, więc:

  1. przypisano nowy klucz dla elementu
  2. null jest używany jako jego wartość

OSTRZEŻENIE:
Pamiętaj, że ta ostatnia funkcja jest jedynie pozostałością po poprzednich funkcjach i prawdopodobnie jest całkowicie bezużyteczna. Poleganie na tej funkcji jest wysoce odradzane, ponieważ ta funkcja będzie losowo przestarzała i niespodziewanie zmieniana w przyszłych wydaniach.

UWAGA:
W przeciwieństwie do in array_map, wszystkie parametry niebędące array_map_assocmacierzami, z wyjątkiem pierwszego parametru wywołania zwrotnego, są dyskretnie rzutowane na tablice.

PRZYKŁADY:
// TODO: examples, anyone?