Gibt es eine Möglichkeit, so etwas zu tun:

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

Aber anstatt die Variable aufzurufen array_keysund array_valuesdirekt zu übergeben $test_array?

Die gewünschte Ausgabe ist:

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

Nicht mit array_map, da es keine Schlüssel verarbeitet.

array_walk macht:

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

Es ändert jedoch das als Parameter angegebene Array, so dass es nicht genau funktionale Programmierung ist (da Sie die Frage so markiert haben). Wie im Kommentar erwähnt, werden dadurch nur die Werte des Arrays geändert, sodass die Schlüssel nicht den Angaben in der Frage entsprechen.

Sie könnten eine Funktion schreiben, die die Punkte über sich selbst korrigiert, wenn Sie möchten, wie folgt:

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

Dies ist wahrscheinlich die kürzeste und am einfachsten zu begründende:

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

Hier ist meine sehr einfache, PHP 5.5-kompatible Lösung:

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

Der von Ihnen angegebene Callable sollte selbst ein Array mit zwei Werten zurückgeben, d return [key, value]. H. Der innere Aufruf von array_maperzeugt daher ein Array von Arrays. Dies wird dann von zurück in ein eindimensionales Array konvertiert array_column.

Verwendung

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

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

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

Ausgabe

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

Teilanwendung

Falls Sie die Funktion mehrmals mit verschiedenen Arrays, aber derselben Zuordnungsfunktion verwenden müssen, können Sie eine sogenannte Teilfunktionsanwendung (im Zusammenhang mit ' Currying ') ausführen , mit der Sie das Datenarray nur beim Aufruf übergeben können:

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

Welches erzeugt die gleiche Ausgabe, gegeben $funcund $ordinalssind wie früher.

HINWEIS: Wenn Ihre zugeordnete Funktion dieselbe Taste für zwei verschiedene Eingaben zurückgibt , gewinnt der mit der späteren Taste verknüpfte Wert . Kehren Sie das Eingabearray und das Ausgabeergebnis von array_map_assocum, damit frühere Schlüssel gewinnen können. (Die zurückgegebenen Schlüssel in meinem Beispiel können nicht kollidieren, da sie den Schlüssel des Quellarrays enthalten, der wiederum eindeutig sein muss.)

Alternative

Das Folgende ist eine Variante der oben genannten, die sich für einige als logischer erweisen könnte, aber PHP 5.6 erfordert:

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

In dieser Variante sollte Ihre bereitgestellte Funktion (über die das Datenarray zugeordnet ist) stattdessen ein assoziatives Array mit einer Zeile zurückgeben, d return [key => value]. H. Das Ergebnis der Zuordnung des aufrufbaren Objekts wird dann einfach entpackt und an übergeben array_merge. Wie zuvor führt die Rückgabe eines doppelten Schlüssels dazu, dass spätere Werte gewinnen.

nb Alex83690 hat in einem Kommentar festgestellt, dass die Verwendung array_replacehier anstelle von array_mergeGanzzahlschlüsseln erhalten würde. array_replaceÄndert das Eingabearray nicht, ist also für den Funktionscode sicher.

Wenn Sie mit PHP 5.3 bis 5.5 arbeiten, entspricht Folgendes. Es verwendet array_reduceund den binären +Array-Operator, um das resultierende zweidimensionale Array in ein eindimensionales Array zu konvertieren, wobei die Schlüssel erhalten bleiben:

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

Verwendung

Diese beiden Varianten würden also verwendet:

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

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

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

Beachten Sie die =>statt ,in $func.

Die Ausgabe ist dieselbe wie zuvor und kann teilweise auf dieselbe Weise wie zuvor angewendet werden.

 Zusammenfassung

Das Ziel der ursprünglichen Frage ist es, den Aufruf des Aufrufs so einfach wie möglich zu gestalten, auf Kosten einer komplizierteren Funktion, die aufgerufen wird. insbesondere, um das Datenarray als einzelnes Argument übergeben zu können, ohne die Schlüssel und Werte aufzuteilen. Verwenden Sie die zu Beginn dieser Antwort angegebene Funktion:

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

Oder wir können nur für diese Frage eine array_map_assoc()Funktionsvereinfachung vornehmen , bei der die Ausgabetasten gelöscht werden, da die Frage nicht nach ihnen fragt:

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

Die Antwort lautet also NEIN . Sie können es nicht vermeiden, anzurufen array_keys, aber Sie können den Ort, an dem array_keysder Aufruf erfolgt, in eine Funktion höherer Ordnung abstrahieren , was möglicherweise gut genug ist.

Mit PHP5.3 oder höher:

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

So habe ich das in meinem Projekt umgesetzt.

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

Schau hier! Es gibt eine triviale Lösung!

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

Wie in der Frage angegeben, hat array_map bereits genau die Funktionalität erforderlich . Die anderen Antworten hier überkomplizieren die Dinge ernsthaft: array_walksind nicht funktionsfähig.

Verwendung

Genau so, wie Sie es von Ihrem Beispiel erwarten würden:

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

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

Mit "manuelle Schleife" meinte ich das Schreiben einer benutzerdefinierten Funktion, die verwendet foreach. Dies gibt ein neues Array zurück, wie array_mapdies der Fall ist, da der Funktionsumfang $arrayeine Kopie und keine Referenz verursacht:

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

Ihre Technik array_mapmit array_keysobwohl scheint tatsächlich einfacher und leistungsfähiger zu sein, da Sie sie nullals Rückruf verwenden können, um die Schlüssel-Wert-Paare zurückzugeben:

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

Basierend auf der Antwort von eis habe ich Folgendes getan, um zu vermeiden, dass das ursprüngliche Array durcheinander gebracht wird:

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

Ich habe diese Funktion basierend auf der Antwort von eis erstellt :

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

Beispiel:

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

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

Ausgabe:

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

Natürlich können Sie damit array_valuesgenau das zurückgeben, was OP will.

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

Die YaLinqo- Bibliothek * ist für diese Art von Aufgabe gut geeignet. Es ist ein Port von LINQ aus .NET, der Werte und Schlüssel in allen Rückrufen vollständig unterstützt und SQL ähnelt. Beispielsweise:

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

oder nur:

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

Hier '"$k loves $v"'ist eine Verknüpfung für die vollständige Schließungssyntax, die diese Bibliothek unterstützt. toArray()am Ende ist optional. Die Methodenkette gibt einen Iterator zurück. Wenn das Ergebnis nur mit iteriert werden muss foreach, toArraykann der Aufruf entfernt werden.

_{* von mir entwickelt}

Ich würde so etwas machen:

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

?>

Ergebnisse:

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

Ich werde noch eine weitere Lösung für das Problem mit Version 5.6 oder höher hinzufügen. Ich weiß nicht, ob es effizienter ist als die bereits großartigen Lösungen (wahrscheinlich nicht), aber für mich ist es einfach einfacher zu lesen:

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

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

Unter Verwendung strval()als Beispiel Funktion in dem array_map, werden diese erzeugen:

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

Hoffentlich bin ich nicht der einzige, der das ziemlich einfach zu verstehen findet. array_combineErstellt ein key => valueArray aus einem Array von Schlüsseln und einem Array von Werten, der Rest ist ziemlich selbsterklärend.

Sie können die Kartenmethode aus dieser Array-Bibliothek verwenden , um genau das zu erreichen, was Sie möchten:

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

Außerdem werden Schlüssel beibehalten und neue Arrays zurückgegeben, ganz zu schweigen von einigen verschiedenen Modi, die Ihren Anforderungen entsprechen.

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

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

Quelle

Ich mag immer die Javascript-Variante der Array-Map. Die einfachste Version davon wäre:

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

Jetzt können Sie ihm einfach eine Rückruffunktion zum Erstellen der Werte übergeben.

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

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

Eine andere Möglichkeit, dies mit (out) Schlüssel zu tun:

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

Ich sehe, es fehlt die offensichtliche Antwort:

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

Funktioniert genau wie array_map. Fast.

Eigentlich ist es nicht rein, mapwie Sie es aus anderen Sprachen kennen. PHP ist sehr seltsam, daher erfordert es einige sehr seltsame Benutzerfunktionen, denn wir wollen unsere genau gebrochenen nicht auflösenworse is better Ansatz .

Wirklich, es ist überhaupt nicht map. Trotzdem ist es sehr nützlich.

• Der erste offensichtliche Unterschied zu array_map besteht darin, dass der Rückruf Ausgaben each()von jedem Eingabearray anstelle von Werten allein übernimmt . Sie können immer noch mehrere Arrays gleichzeitig durchlaufen.

• Der zweite Unterschied ist die Art und Weise, wie der Schlüssel behandelt wird, nachdem er vom Rückruf zurückgegeben wurde. Der Rückgabewert der Rückruffunktion sollte sein array('new_key', 'new_value'). Schlüssel können und werden geändert, dieselben Schlüssel können sogar dazu führen, dass der vorherige Wert überschrieben wird, wenn derselbe Schlüssel zurückgegeben wurde. Dies ist kein allgemeines mapVerhalten, ermöglicht jedoch das Umschreiben von Schlüsseln.

• Die dritte seltsame Sache ist, wenn Sie den keyRückgabewert weglassen (entweder von array(1 => 'value')oder array(null, 'value')), wird ein neuer Schlüssel zugewiesen, als ob er $array[] = $valueverwendet worden wäre. Das ist auch nicht mapdas übliche Verhalten, aber es ist manchmal praktisch, denke ich.

• Die vierte seltsame Sache ist, wenn die Rückruffunktion keinen Wert zurückgibt oder zurückgibt null, wird der gesamte Satz aktueller Schlüssel und Werte in der Ausgabe weggelassen und einfach übersprungen. Diese Funktion ist völlig mapeinzigartig, aber sie würde diese Funktion zu einem hervorragenden Stunt-Double machen array_filter_assoc, wenn es eine solche Funktion gäbe.

• Wenn Sie das zweite Element ( 1 => ...) (den Wertteil ) in der Rückrufrückgabe weglassen , nullwird anstelle des realen Werts verwendet.

• Alle anderen Elemente außer denen mit Schlüsseln 0und 1in der Rückrufrückgabe werden ignoriert.

• Und schließlich, wenn Lambda einen Wert außer nulloder Array zurückgibt , wird es so behandelt, als ob sowohl Schlüssel als auch Wert weggelassen würden, also:

  1. neuer Schlüssel für Element wird zugewiesen
  2. null wird als Wert verwendet

WARNUNG:
Beachten Sie, dass diese letzte Funktion nur ein Rest der vorherigen Funktionen ist und wahrscheinlich völlig unbrauchbar ist. Unter Berufung auf diese Funktion wird dringend abgeraten, da diese Funktion zufällig werden wird als veraltet in zukünftigen Versionen und unerwartet geändert wird.

HINWEIS:
Im Gegensatz zu in array_mapwerden alle Nicht-Array-Parameter array_map_assocmit Ausnahme des ersten Rückrufparameters stillschweigend in Arrays umgewandelt.

BEISPIELE:
// TODO: examples, anyone?