la fonction json_decode de classe personnalisée

Est-il possible de décoder une chaîne json pour un objet autre que stdClass?

InformationsquelleAutor Tom | 2011-03-22
  1. 84

    Pas automatiquement. Mais vous pouvez le faire à l'ancienne route.

    $data = json_decode($json, true);

$class = new Whatever();
foreach ($data as $key => $value) $class->{$key} = $value;

    Ou sinon, vous pourrait rendre plus automatique:

    class Whatever {
    public function set($data) {
        foreach ($data AS $key => $value) $this->{$key} = $value;
    }
}

$class = new Whatever();
$class->set($data);

    Modifier: arriver un peu plus sophistiqué:

    class JSONObject {
    public function __construct($json = false) {
        if ($json) $this->set(json_decode($json, true));
    }

    public function set($data) {
        foreach ($data AS $key => $value) {
            if (is_array($value)) {
                $sub = new JSONObject;
                $sub->set($value);
                $value = $sub;
            }
            $this->{$key} = $value;
        }
    }
}

//These next steps aren't necessary. I'm just prepping test data.
$data = array(
    "this" => "that",
    "what" => "who",
    "how" => "dy",
    "multi" => array(
        "more" => "stuff"
    )
);
$jsonString = json_encode($data);

//Here's the sweetness.
$class = new JSONObject($jsonString);
print_r($class);
    • J'ai comme vous des suggestions, juste de remarquer qu'il ne fonctionne pas avec les objets imbriqués (autres que STDClass ou la conversion d'un objet)
    InformationsquelleAutor Michael McTiernan
  2. 24

    Vous pouvez le faire - c'est une bidouille, mais tout à fait possible. Nous avons eu à faire lorsque l'on a commencé à stocker des choses dans couchbase.

    $stdobj = json_decode($json_encoded_myClassInstance);  //JSON to stdClass
$temp = serialize($stdobj);                   //stdClass to serialized

//Now we reach in and change the class of the serialized object
$temp = preg_replace('@^O:8:"stdClass":@','O:7:"MyClass":',$temp);

//Unserialize and walk away like nothing happend
$myClassInstance = unserialize($temp);   //Presto a php Class

    Dans nos benchmarks ce fut bien plus rapide que d'essayer de parcourir toutes les variables de classe.

    Mise en garde: ne fonctionne pas pour les objets imbriqués autres que stdClass

    Edit: gardez à l'esprit de la source de données, il est fortement recommandé que vous ne le faites pas avec les données non fiables auprès des utilisateurs sans sans altération de l'analyse des risques.

    • Est-ce de travailler avec encapsulé sous-classes. E. g. { "a": {"b":"c"} }, où l'objet dans a est d'une autre classe et pas seulement un tableau associatif?
    • non, la fonction json_decode crée stdclass objets, y compris les sous-objets, si vous voulez avoir autre chose que vous devez faire quelque chose de chaque objet comme ci-dessus.
    • Merci, c'est ce que j'ai imaginé
    • Comment on utilise cette solution sur des objets où le constructeur a des paramètres. Je ne peux pas le faire fonctionner. J'espérais que quelqu'un pourrait me diriger dans la bonne direction pour faire de cette solution est de travailler avec un objet qui a un constructeur personnalisé avec des paramètres.
    InformationsquelleAutor John Pettitt
  3. 21

    Nous avons construit JsonMapper pour mapper des objets JSON sur notre propre modèle de classes automatiquement. Il fonctionne très bien avec imbriqué/objets enfants.

    Il ne repose que sur les docblock type d'information pour la cartographie, la plupart des propriétés de la classe ont de toute façon:

    <?php
$mapper = new JsonMapper();
$contactObject = $mapper->map(
    json_decode(file_get_contents('http://example.org/contact.json')),
    new Contact()
);
?>
    • de nombreux thx pour votre grande bibliothèque.
    • WOW! C'est tout simplement incroyable.
    InformationsquelleAutor cweiske
  4. 11

    Vous pouvez utiliser Johannes Schmitt Sérialiseur bibliothèque.

    $serializer = JMS\Serializer\SerializerBuilder::create()->build();
$object = $serializer->deserialize($jsonData, 'MyNamespace\MyObject', 'json');

    Dans la dernière version de la JMS sérialiseur la syntaxe est la suivante:

    $serializer = SerializerBuilder::create()->build();
$object = $serializer->deserialize($jsonData, MyObject::class, 'json');
    • La syntaxe n'est pas dépendante de JMS Sérialiseur version, mais plutôt sur la version de PHP - à partir de PHP5.5 vous pouvez utiliser ::class notation: php.net/manual/en/...
    InformationsquelleAutor Malachi
  5. 3

    Non, ce n'est pas possible de PHP 5.5.1.

    La seule chose possible est d'avoir json_decode retour associer des tableaux au lieu de la StdClass objets.

    InformationsquelleAutor Gordon
  6. 3

    Vous pouvez faire un wrapper pour votre objet et de faire le wrapper ressembler à elle est l'objet lui-même. Et il va travailler avec multi-niveaux des objets.

    <?php
class Obj
{
    public $slave;

    public function __get($key) {
        return property_exists ( $this->slave ,  $key ) ? $this->slave->{$key} : null;
    }

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

$std = json_decode('{"s3":{"s2":{"s1":777}}}');

$o = new Obj($std);

echo $o->s3->s2->s1; //you will have 777
    InformationsquelleAutor Yevgeniy Afanasyev
  7. 1

    Vous pouvez le faire en dessous de la place .. 

    <?php
class CatalogProduct
{
    public $product_id;
    public $sku;
    public $name;
    public $set;
    public $type;
    public $category_ids;
    public $website_ids;

    function __construct(array $data) 
    {
        foreach($data as $key => $val)
        {
            if(property_exists(__CLASS__,$key))
            {
                $this->$key =  $val;
            }
        }
    }
}

    ?>

    Pour plus de détails, visitez
    créer-custom-classe-en-php-de-json-ou-tableau

    InformationsquelleAutor jigarshahindia
  8. 0

    Que Gordon dit n'est pas possible. Mais si vous êtes à la recherche d'un moyen d'obtenir une chaîne de caractères qui peut être décodé comme une instance de donner de la classe, vous pouvez utiliser sérialiser et unserialize à la place.

    class Foo
{

    protected $bar = 'Hello World';

    function getBar() {
        return $this->bar;
    }

}

$string = serialize(new Foo);

$foo = unserialize($string);
echo $foo->getBar();
    • Cela ne semble pas répondre à la question. Si c'est le cas, vous devrez fournir quelques explications.
    • J'ai expliqué mon point de vue 😛
    InformationsquelleAutor Francesco Terenzani
  9. 0

    Une fois, j'ai créé une classe de base abstraite pour ce but. Appelons ça de la JsonConvertible. Il devrait sérialiser et désérialiser les membres du public. C'est possible grâce à la Réflexion et à la fin statique de la liaison.

    abstract class JsonConvertible {
   static function fromJson($json) {
       $result = new static();
       $objJson = json_decode($json);
       $class = new \ReflectionClass($result);
       $publicProps = $class->getProperties(\ReflectionProperty::IS_PUBLIC);
       foreach ($publicProps as $prop) {
            $propName = $prop->name;
            if (isset($objJson->$propName) {
                $prop->setValue($result, $objJson->$propName);
            }
            else {
                $prop->setValue($result, null);
            }
       }
       return $result;
   }
   function toJson() {
      return json_encode($this);
   }
} 

class MyClass extends JsonConvertible {
   public $name;
   public $whatever;
}
$mine = MyClass::fromJson('{"name": "My Name", "whatever": "Whatever"}');
echo $mine->toJson();

    Seulement à partir de la mémoire, donc probablement pas sans faille. Vous aurez également à exclure les propriétés statiques et peuvent donner des classes dérivées de la chance de faire quelques propriétés ignorées lors de sérialisé vers/à partir de json. J'espère que vous avez l'idée, néanmoins.

    InformationsquelleAutor klawipo
  10. -1

    JSON est un protocole simple de transfert de données entre les différents langages de programmation (et c'est aussi un sous-ensemble de JavaScript) qui prend en charge certains types: nombres, chaînes de caractères, les tableaux/listes, des objets/dicts. Les objets sont juste la clé=valeur des cartes et des Tableaux sont des listes ordonnées.

    Donc il n'y a aucun moyen d'exprimer des objets personnalisés de manière générique. La solution est la définition d'une structure où votre programme(s) sachez que c'est un objet personnalisé.

    Voici un exemple:

    { "cls": "MyClass", fields: { "a": 123, "foo": "bar" } }

    Cela pourrait être utilisé pour créer une instance de MyClass et de définir les champs de a et foo à 123 et "bar".

    • Cela peut être vrai, mais la question n'est pas de poser sur la représentation des objets de manière générique. On dirait qu'il en a une spécifique JSON sac qui correspond à une classe spécifique sur une ou aux deux extrémités. Il n'y a aucune raison que vous ne pouvez pas utiliser JSON comme l'explicite la sérialisation de non-générique nommé classes de cette façon. Le nommer comme vous le faites est très bien si vous voulez une solution générique, mais il y a aussi rien de mal à avoir convenu d'un contrat sur la structure JSON.
    InformationsquelleAutor ThiefMaster