PHP – rekursives Array zu Objekt?

Gibt es eine Möglichkeit, eine mehrdimensionale zu konvertieren array zu einem stdClass Objekt in PHP?

Casting als (object) scheint nicht rekursiv zu funktionieren. json_decode(json_encode($array)) erzeugt das Ergebnis, das ich suche, aber es muss einen besseren Weg geben …

Soweit ich das beurteilen kann, gibt es dafür keine vorgefertigte Lösung, sodass Sie einfach Ihre eigene erstellen können:

function array_to_object($array) {
   $obj = new stdClass();

   foreach ($array as $k => $v) {
      if (strlen($k)) {
         if (is_array($v)) {
            $obj->{$k} = array_to_object($v); //RECURSION
         } else {
            $obj->{$k} = $v;
         }
      }
   }
   
   return $obj;
}

Ich weiß, dass diese Antwort spät kommt, aber ich werde sie für alle posten, die nach einer Lösung suchen.

Anstelle all dieser Schleifen usw. können Sie die native Funktion json_* von PHP verwenden. Ich habe ein paar praktische Funktionen, die ich oft benutze

/**
 * Convert an array into a stdClass()
 * 
 * @param   array   $array  The array we want to convert
 * 
 * @return  object
 */
function arrayToObject($array)
{
    // First we convert the array to a json string
    $json = json_encode($array);

    // The we convert the json string to a stdClass()
    $object = json_decode($json);

    return $object;
}


/**
 * Convert a object to an array
 * 
 * @param   object  $object The object we want to convert
 * 
 * @return  array
 */
function objectToArray($object)
{
    // First we convert the object into a json string
    $json = json_encode($object);

    // Then we convert the json string to an array
    $array = json_decode($json, true);

    return $array;
}

Hoffe, das kann hilfreich sein

Sie und viele andere haben auf die integrierten JSON-Funktionen hingewiesen, json_decode() und json_encode(). Die Methode, die Sie erwähnt haben, funktioniert, aber nicht vollständig: Sie konvertiert keine indizierten Arrays in Objekte und sie bleiben als indizierte Arrays erhalten. Es gibt jedoch einen Trick, um dieses Problem zu umgehen. Sie können verwenden JSON_FORCE_OBJECT Konstante:

// Converts an array to an object recursively
$object = json_decode(json_encode($array, JSON_FORCE_OBJECT));

Tipp: Auch, wie erwähnt hierkönnen Sie ein Objekt mithilfe von JSON-Funktionen rekursiv in ein Array konvertieren:

// Converts an object to an array recursively
$array = json_decode(json_encode($object), true));    

Wichtiger Hinweis: Wenn Ihnen die Leistung wichtig ist, verwenden Sie diese Methode nicht. Es ist zwar kurz und sauber, aber es ist das langsamste unter den Alternativen. Siehe meine andere Antwort in diesem Thread zu diesem Thema.

function toObject($array) {
    $obj = new stdClass();
    foreach ($array as $key => $val) {
        $obj->$key = is_array($val) ? toObject($val) : $val;
    }
    return $obj;
}

Du kannst den … benutzen array_map rekursiv:

public static function _arrayToObject($array) {
    return is_array($array) ? (object) array_map([__CLASS__, __METHOD__], $array) : $array;
}

Funktioniert perfekt für mich, da es zum Beispiel keine Carbon-Objekte in eine grundlegende stdClass umwandelt (was die json-Codierung/Decodierung tut).

/**
 * Recursively converts associative arrays to stdClass while keeping integer keys subarrays as arrays
 * (lists of scalar values or collection of objects).
 */
function a2o( array $array ) {
    $resultObj = new \stdClass;
    $resultArr = array();
    $hasIntKeys = false;
    $hasStrKeys = false;
    foreach ( $array as $k => $v ) {
        if ( !$hasIntKeys ) {
            $hasIntKeys = is_int( $k );
        }
        if ( !$hasStrKeys ) {
            $hasStrKeys = is_string( $k );
        }
        if ( $hasIntKeys && $hasStrKeys ) {
            $e = new \Exception( 'Current level has both integer and string keys, thus it is impossible to keep array or convert to object' );
            $e->vars = array( 'level' => $array );
            throw $e;
        }
        if ( $hasStrKeys ) {
            $resultObj->{$k} = is_array( $v ) ? a2o( $v ) : $v;
        } else {
            $resultArr[$k] = is_array( $v ) ? a2o( $v ) : $v;
        }
    }
    return ($hasStrKeys) ? $resultObj : $resultArr;
} 

Einige der anderen hier geposteten Lösungen können sequentielle Arrays nicht auseinanderhalten (was wäre [] in JS) aus Karten ({} in JS.) Für viele Anwendungsfälle ist es wichtig, PHP-Arrays, die alle fortlaufende numerische Schlüssel haben, die so belassen werden sollten, von PHP-Arrays zu unterscheiden, die keine numerischen Schlüssel haben, die in Objekte umgewandelt werden sollten. (Meine Lösungen unten sind für Arrays, die nicht in die beiden oben genannten Kategorien fallen, nicht definiert.)

Das json_decode(json_encode($x)) -Methode behandelt die beiden Typen korrekt, ist aber nicht die schnellste Lösung. Insgesamt ist es aber immer noch anständig 25µs pro Lauf mit meinen Beispieldaten (gemittelt über 1 Mio. Läufe, abzüglich des Loop-Overheads.)

Ich habe ein paar Variationen des rekursiven Konverters getestet und bin zu folgendem Ergebnis gekommen. Es erstellt alle Arrays und Objekte neu (durch Ausführen einer tiefen Kopie), scheint jedoch schneller zu sein als alternative Lösungen, die die vorhandenen Arrays ändern. Es schlägt um 11µs pro Ausführung meiner Beispieldaten:

function array_to_object($x) {
    if (!is_array($x)) {
        return $x;
    } elseif (is_numeric(key($x))) {
        return array_map(__FUNCTION__, $x);
    } else {
        return (object) array_map(__FUNCTION__, $x);
    }
}

Hier ist eine In-Place-Version. Bei einigen großen Eingabedaten, bei denen nur kleine Teile konvertiert werden müssen, kann es schneller sein, aber bei meinen Beispieldaten hat es gedauert 15µs pro Ausführung:

function array_to_object_inplace(&$x) {
    if (!is_array($x)) {
        return;
    }
    array_walk($x, __FUNCTION__);
    reset($x);
    if (!is_numeric(key($x))) {
        $x = (object) $x;
    }
}

Lösungen mit habe ich nicht ausprobiert array_walk_recursive()