PHP-tableau récursif à L'objet?

Je sais que cette réponse arrive en retard mais je la posterai pour tous ceux qui recherchent une solution.

Au lieu de tout cela, vous pouvez utiliser la fonction json_* native de PHP. J'ai quelques fonctions pratiques que j'utilise beaucoup

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

J'Espère que cela peut être utile

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

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

Certaines des autres solutions affichées ici ne parviennent pas à distinguer les tableaux séquentiels (ce qui serait [] dans JS) des cartes ({} dans JS.) Pour de nombreux cas d'utilisation, il est important de distinguer les tableaux PHP qui ont toutes les clés numériques séquentielles, qui doivent être laissées en tant que telles, des tableaux PHP qui n'ont pas de clés numériques, qui doivent être convertis en objets. (Mes solutions ci-dessous ne sont pas définies pour les tableaux qui ne tombent pas dans les deux catégories ci-dessus.)

La méthode json_decode(json_encode($x)) gère les deux types correctement, mais n'est pas la solution la plus rapide. Il est toujours décent cependant, totalisant 25µs par exécution sur mes exemples de données (en moyenne sur 1m de courses, moins la surcharge de la boucle.)

J'ai comparé quelques variations du convertisseur récursif et j'ai fini avec ce qui suit. Il reconstruit tous les tableaux et objets (en effectuant une copie profonde) mais semble être plus rapide que les solutions alternatives qui modifient les tableaux en place. Il horloges à 11µs par exécution sur mon échantillon données:

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

Voici une version sur place. Il peut être plus rapide sur certaines grandes données d'entrée où seules de petites pièces doivent être converties, mais sur mes exemples de données, il a fallu 15µs par exécution:

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

Je n'ai pas essayé de solutions en utilisant array_walk_recursive()

Vous pouvez utiliser le array_map récursivement:

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

Fonctionne parfaitement pour moi car il ne convertit pas par exemple les objets Carbon en une classe stdClass de base (ce que le JSON encode/decode fait)

Le moyen le plus simple de convertir un tableau associatif en objet est:

Encodez-le D'abord en json, puis décodez-le.

Comme $objectArray = json_decode(json_encode($associtiveArray));

public static function _arrayToObject($array) {
    $json = json_encode($array);
    $object = json_decode($json);
    return $object
}

Voici une fonction pour effectuer une conversion de tableau en objet en profondeur qui utilise un mécanisme de conversion de type tableau en objet interne (peu profond) de PHP. Il ne crée de nouveaux objets que lorsque cela est nécessaire, minimisant ainsi la duplication des données.

function toObject($array) {
    foreach ($array as $key=>$value)
        if (is_array($value))
            $array[$key] = toObject($value);
    return (object)$array;
}

Avertissement - n'utilisez pas ce code s'il y a un risque d'avoir des références circulaires.

Voici une façon fluide de le faire qui peut gérer un tableau associatif avec une grande profondeur et n'écrase pas les propriétés d'objet qui ne sont pas dans le tableau.

    <?php

    function setPropsViaArray( $a, $o )
    {
        foreach ( $a as $k => $v )
        {
            if ( is_array( $v ) )
            {
                $o->{$k} = setPropsViaArray( $v, ! empty ( $o->{$k} ) ? $o->{$k} : new stdClass() );
            }
            else
            {
                $o->{$k} = $v;
            }
        }
        return $o;
    };

    setPropsViaArray( $newArrayData, $existingObject );

Le plus court que je pourrais trouver:

array_walk_recursive($obj, function (&$val) { if (is_object($val)) $val = get_object_vars($val); });

En retard, mais je voulais juste mentionner que vous pouvez utiliser l'encodage / décodage JSON pour convertir complètement de / en tableau:

//convert object $object into array
$array = json_decode(json_encode($object), true);
//convert array $array into object
$object = json_decode(json_encode($array));

Les fonctions Json_encode et json_decode sont disponibles à partir de php 5.2

EDIT: Cette fonction est la conversion de l'objet en tableau.

À Partir de https://forrst.com/posts/PHP_Recursive_Object_to_Array_good_for_handling-0ka

protected function object_to_array($obj)
{
    $arrObj = is_object($obj) ? get_object_vars($obj) : $obj;
    foreach ($arrObj as $key => $val) {
            $val = (is_array($val) || is_object($val)) ? $this->object_to_array($val) : $val;
            $arr[$key] = $val;
    }
    return $arr;
}