PHPs array_map mit Schlüsseln

207

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"
}
José Tomás Tocino
quelle
Siehe auch: stackoverflow.com/search?q=each_with_index für einen kontrastierenden Ansatz zu diesem allgemeinen Problem
dreftymac

Antworten:

204

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"
// }
eis
quelle
In diesem Fall möchten Sie jedoch $a = "$b loves $a"die gewünschte Ausgabe des OP erreichen.
cmbuckley
1
richtig, geändert :) es ist schön, wie unterschiedlich sie array_map von array_walk gemacht haben.
Eis
Nett, danke. Um zu vermeiden, dass das ursprüngliche Array
durcheinander gebracht wird
3
Dies ist jedoch keine "funktionale Programmierung", da array_walk()nicht das resultierende Array zurückgegeben wird, sondern ein Bool.
Mae
@mae ja, wie ich auch in der Antwort geschrieben habe - anstatt den Wert zurückzugeben, ändert es den Parameter
eis
145

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')
)
Kevin Beal
quelle
15
Ich habe gerade festgestellt, dass die Frage ausdrücklich sagte, nicht zu verwenden array_keys(). Das scheint jedoch eine dumme Anforderung zu sein.
Kevin Beal
3
Die Frage lieferte eine Lösung mit array_keys (). Es wäre dumm, eine Antwort zu geben, die keinen Vorteil gegenüber der aktuellen Lösung hat (z. B. weniger Funktionen aufruft).
Chinoto Vokro
Die Antwort auf die ursprüngliche Frage lautet NEIN, und dies ist die am besten geeignete Lösung.
Usoban
65

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.

Nicholas Shanks
quelle
7
Scheint so, als sollte dies als die richtige Antwort markiert werden.
Eddiewould
6
Danke @eddiewould, aber ich bin ungefähr 4½ Jahre zu spät :) Ich bin hierher gekommen, um nach einer Lösung zu suchen, habe keine gefunden, die mir gefallen hat, also habe ich mir eine eigene ausgedacht.
Nicholas Shanks
1
Ich werde DIESER Typ sein. PHP 5.3 sollte für das Datum dieser Antwort nicht mehr erforderlich sein . MEINER BESCHEIDENEN MEINUNG NACH.
Erutan409
1
Ihre erste alternative Lösung ist ungültig. Sie ersetzen müssen array_mergedurch array_replaceTasten zu erhalten , die ganzen Zahlen sein würde.
Alex83690
1
@ Alex83690 Danke! Obwohl ich sagen würde, dass "ungültig" leicht irreführend ist - es ist in Ordnung, wenn Sie keine Ganzzahlschlüssel haben (wie in meinem Fall).
Nicholas Shanks
20

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)
    )
);
Tadas Sasnauskas
quelle
1
Ich denke, die Anforderung lautete: "Anstatt array_keys und array_values ​​aufzurufen und die Variable $ test_array direkt zu übergeben", kann dies ohne array_keys verwendet werden?
Eis
4

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));
}
Jijo
quelle
Sehr sauber und verändert das ursprüngliche Array nicht!
Raffaele Candeliere
4

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));
IanS
quelle
Die anderen Antworten sind qrrqy_keys()zu kompliziert, da die angegebene Frage nicht für #reasons verwendet werden sollte
Brad Kent
2

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);
}
Ryanve
quelle
Das Schleifen eines Arrays mit Referenz kann dazu führen , dass
gruselige
Es ist nicht gruselig, es bedeutet nur, dass Sie es vergessen haben, unset( $value )weil es noch im definierten Bereich existiert.
Aziz Punjani
@azis, machte Witze über die Gruseligkeit und bezog sich auf den Artikel. Es werden unerwartete Effekte erzeugt, wenn Sie das Deaktivieren vergessen.
Janenz00
1
Vielen Dank für die Antwort, aber ich fand es ziemlich klar, dass ich keine traditionelle Schleife verwenden wollte.
José Tomás Tocino
@ janenz00 Siehe bearbeitete Antwort zur Verdeutlichung. Ich meinte eine Schleife in einem sauberen variablen Bereich.
Ryanve
1

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);
José Tomás Tocino
quelle
2
Warum ist dies einfacher, als nur die Array-Werte und -Schlüssel direkt an array_map zu übergeben? Es ist langsamer und komplizierter, ich sehe den Vorteil nicht.
Ariel
1
@Ariel können Sie die Behauptung stützen, dass es auch bei großen Zahlen langsamer wäre? Es muss das Array nur einmal iterieren, daher denke ich, dass es in der großen O-Notation um Größenordnungen schneller sein sollte. Ich stimme jedoch der Komplexität zu.
Eis
@eis Es ist langsamer, weil es das Ergebnisarray einzeln in PHP erstellt, anstatt in C in Massen. Es vermeidet jedoch den Aufruf von array_keys (obwohl dies schnell ist, da es in C ist). Benchmarking - sehen Sie, was schneller ist, ich bin nicht wirklich sicher, aber normalerweise mehr Code = langsamerer Code. In der Komplexität ist es definitiv schlimmer, und das ist die meiste Zeit wichtiger als die Geschwindigkeit.
Ariel
1
Sie müssen das dritte Argument nicht an senden, array_walkda Sie es im Abschluss nicht referenzieren.
Steven Lu
1

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))
Julio Vedovatto
quelle
@ KevinBeal Ich benutze diese Funktion häufig in meiner Arbeit. Könnten Sie zeigen, wo die Fehler sind?
Julio Vedovatto
2
Zunächst wird der Code , wie es steht eine Prüfung fehlt , die $arrvom Typ Array ist, aber wenn Sie Ihre Argumente typ andeuten , wie callableund arraySie können stattdessen den Scheck fallen is_callable. Als Nächstes weisen Sie $ value eine Zuweisung zu, die dann nicht verwendet wird. Sie sollten den Rückgabewert einfach ignorieren. Drittens wäre es besser, eine Ausnahme in den Rückruf zu werfen, als false zurückzugeben. Sie würden dann entweder immer einen gültigen Wert zurückgeben oder immer werfen.
Nicholas Shanks
1

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

Athari
quelle
1

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"
}
Koala Yeung
quelle
1

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.

Francesco DM
quelle
1

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.

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

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

Quelle

Ostap B.
quelle
0

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;
    });
);
bla bla bla
quelle
Es ist sinnvoller , die Daten als das letzte Argument für jede Funktion haben Sie schreiben, da Sie dann eine neue Funktion erstellen können , dass backt-in einigen spezifischen Rückruf (Verhalten) - dh Sie Funktion Zusammensetzung erhalten: h(g(f($data)))gilt f, dann g, dann hauf Ihre Daten. In der funktionalen Programmierung wird es allgemein als vielseitiger angesehen, eine Funktion zu haben, die dieselbe Operation für Taucherdaten ausführt, als eine Funktion, die Taucherfunktionen auf einen festen Datensatz anwendet.
Nicholas Shanks
In Ihrem Beispiel haben Sie nur 1 Argument für die Funktion. Ich finde es einfacher, die Daten als erstes Argument wie array_filter, array_reduce und die Array-Funktionen in Javascript zu setzen.
Blablabla
Das ist mein Punkt! Indem Sie die Daten zuletzt übergeben, können Sie die Funktion curry (eine neue Funktion erstellen, die die Schleife mit der spezifischen Operation kombiniert) und diese auf die Daten anwenden , indem Sie die neue Funktion mit einem einzigen Parameter aufrufen. Dieses Prinzip wird
Nicholas Shanks
Ist die Verwendung einer Compose-Funktion in einer Sprache wie PHP keine bessere Lösung für dieses Problem?
Blablabla
1
Es ist eine Alternative, erfordert jedoch wesentlich mehr Investitionen in FP, zum Beispiel: github.com/nickshanks/fp-php-talk/blob/master/lib.php#L24 oder dies: github.com/nickshanks/php-fp/blob /master/src/fp.php#L62
Nicholas Shanks
0

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)
);
Blablaenzo
quelle
-2

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?

Enrey
quelle