Kann ich die Schlüssel eines Arrays mit Array-Funktionen wie array_map

Question

Ich mag den funktionalen Programmierstil der Verwendung von Array-Map, um ein Array von Objekten aus einem anderen Array von Objekten zu erstellen.

$newObjects = array_map(
    function($oldObject) { 
    return new NewObject($oldObject); 
    }, 
    $oldObjects 
); 

Welche alles funktioniert gut, aber ich würde wirklich in der Lage sein wie die Indizes des Arrays zu setzen, so dass sie die IDs der ursprünglichen Objekte für eine einfachere Suche und den Abruf aus dem Array sind, aber ich kann nicht glauben, wie man mach es anders als das, was nicht so elegant ist.

$newObjects = array(); 
foreach ($oldObjects as $oldObject) { 
    $newObjects[$oldObject->getId()] = new NewObject($oldObject); 
} 

Gibt es eine Möglichkeit, das kann ich tun?

Answer 1

Was ist, wenn Sie array_walk und ein temporäres Array mit Ihren neuen Indizes verwenden.

$array = ['A', 'B', 'C', 'D']; 
    $reIndexedTemp = []; 

    array_walk(
     $array, 
     function ($item, $key) use (&$reIndexedTemp) { 
      // here you can have your logic to assemble your new index 
      $reIndexedTemp[$key + 100] = $item; 
     } 
    ); 

    //$array = $reIndexedTemp; 

    var_dump($array, $reIndexedTemp); 

Ausgang (ohne die Kommentarzeile):

array(4) { 
    [0] => 
    string(1) "A" 
    [1] => 
    string(1) "B" 
    [2] => 
    string(1) "C" 
    [3] => 
    string(1) "D" 
} 
array(4) { 
    [100] => 
    string(1) "A" 
    [101] => 
    string(1) "B" 
    [102] => 
    string(1) "C" 
    [103] => 
    string(1) "D" 
} 

Answer 2

Umsah - Looking for array_map equivalent to work on keys in associative arrays

Schlägt es array_combine mit funktionieren könnte

Also ich denke, es wäre

sein

$newObjects = array_combine(
    array_map(
    function($oldObject) { 
     return $oldObject->getId(); 
    }, 
    $oldObjects 
), 
    array_map(
    function($oldObject) { 
     return new NewObject($oldObject); 
    }, 
    $oldObjects 
) 
); 

wahrscheinlich

Hmm das Beste, gerade diese Seite von overblown aber auf jeden Fall viel komplexer als die foreach

Answer 3

denke ich, ein foreach ist wahrscheinlich die am besten lesen Lösung in diesem Fall, aber Sie können array_map() mit array_combine() verwenden, um zu erreichen, was Sie wollen. Etwas wie:

// empty array to store the old object ids 
$ids = []; 

// map over old objects, inheriting $id 
// from parent scope by reference 
$objs = array_map(function($oldObject) use (&$ids) { 
    $ids[] = $oldObject->getId(); 
    return new NewObject($oldObject); 
}, $oldObjects); 

// combine id and object arrays 
$newObjects = array_combine($ids, $objs); 

this helps :)

Answer 4

Das heißt - array_reduce() ist genau das, was Sie brauchen:

class Bar 
{ 
     protected $id; 

     public function __construct($id) 
     { 
       $this->id = $id; 
     } 

     public function getId() 
     { 
       return $this->id; 
     } 
} 

class Foo 
{ 
     protected $bar; 

     public function __construct(Bar $bar) 
     { 
       $this->bar = $bar; 
     } 
} 

$oldObjects = [new Bar('x'), new Bar('y'), new Bar('z')]; 

$newObjects = array_reduce($oldObjects, function($current, Bar $obj) { 
     $current[$obj->getId()] = new Foo($obj); 
     return $current; 
}, []); 

Dies wird alles tun, an Ort und Stelle ohne Speicher zusätzlich zu verbringen Arrays wie für array_combine()

Allerdings würde ich vorschlagen, solche Konstrukte zu verwenden, wenn sie notwendig sind. Dies zu verwenden, nur weil es "besser aussieht", ist vielleicht keine gute Idee - da einfache Schleifen in den meisten Fällen einfach lesbarer sind.