<?xml version="1.0" encoding="UTF-8"?>
<!-- EN-Revision: 15617 -->
<!-- Reviewed: no -->
<sect1 id="zend.json.objects">
    <title>Utilisation avancée de Zend_Json</title>

    <sect2 id="zend.json.advanced.objects1">
        <title>Objets JSON</title>

        <para>
            Lorsque vous encodez des objets PHP en tant que JSON, toutes les propriétés publiques
            de cet objet sont encodées dans un objet JSON.
        </para>

        <para>
            JSON ne vous permet pas de référencer des objets, donc le soin devra être pris pour ne
            pas coder des objets avec des références récursives. Si vous avez des problèmes de
            récursivité, <classname>Zend_Json::encode()</classname> et
            <classname>Zend_Json_Encoder::encode()</classname> autorisent un deuxième paramètre
            facultatif afin de vérifier la récursivité ; si un objet est sérialisé deux fois, une
            exception sera levée.
        </para>

        <para>
            Bien que les objets Javascript correspondent de très près aux tableau associatifs de
            PHP, décoder des objets JSON pose une légère difficulté. Certains suggèrent qu'un
            identifiant de classe soit passé, et qu'une instance de cette classe soit créée et
            définie avec les paires clé/valeur des objets JSON ; d'autres pensent que cela pourrait
            poser un risque de sécurité potentiel.
        </para>

        <para>
            Par défaut, <classname>Zend_Json</classname> décodera des objets JSON comme en
            tableaux associatifs. Cependant, si vous désirez avoir un objet en retour, vous pouvez le
            spécifier : <programlisting language="php"><![CDATA[
// Décode des objets JSON en tant qu'objets PHP
$phpNatif = Zend_Json::decode($valeurEncodee, Zend_Json::TYPE_OBJECT);
]]></programlisting> Tous les objets sont ainsi décodés et retournés comme des objets de type
            <code>StdClass</code>, avec leurs propriétés correspondantes aux paires clé/valeur de la
            notation JSON.
        </para>

        <para>
            La recommandation de Zend Framework est que le développeur doit décider comment
            décoder les objets JSON. Si un objet d'un type spécifié doit être créé, il peut être créé
            dans le code du développeur et définit avec les valeurs décodées en utilisant
            <classname>Zend_Json</classname>.
        </para>
    </sect2>

    <sect2 id="zend.json.advanced.objects2">
        <title>Encoding PHP objects</title>

        <para>
            If you are encoding PHP objects by default the encoding mechanism
            can only access public properties of these objects. When a method
            <code>toJson()</code> is implemented on an object to encode,
            <classname>Zend_Json</classname> calls this method and expects the object to return a
            JSON representation of its internal state.
        </para>
    </sect2>

    <sect2 id="zend.json.advanced.internal">
        <title>Internal Encoder/Decoder</title>

        <para>
            Zend_Json has two different modes depending if ext/json is enabled in
            your PHP installation or not. If ext/json is installed by default
            <code>json_encode()</code> and <code>json_decode()</code> functions
            are used for encoding and decoding JSON. If ext/json is not installed
            a Zend Framework implementation in PHP code is used for en-/decoding.
            This is considerably slower than using the php extension, but behaves
            exactly the same.
        </para>

        <para>
            Still sometimes you might want to use the internal encoder/decoder even
            if you have ext/json installed. You can achieve this by calling:
        </para>

        <programlisting language="php"><![CDATA[
Zend_Json::$useBuiltinEncoderDecoder = true:
]]></programlisting>
    </sect2>

    <sect2 id="zend.json.advanced.expr">
        <title>JSON Expressions</title>

        <para>
            Javascript makes heavy use of anonymnous function callbacks, which
            can be saved within JSON object variables. Still they only work if not
            returned inside double qoutes, which <classname>Zend_Json</classname> naturally does.
            With the Expression support for Zend_Json support you can encode JSON
            objects with valid javascript callbacks. This works for both <code>json_encode()</code>
            or the internal encoder.
        </para>

        <para>
            A javascript callback is represented using the <classname>Zend_Json_Expr</classname>
            object. It implements the value object pattern and is immutable. You can set the
            javascript expression as the first constructor argument. By default
            <classname>Zend_Json::encode</classname> does not encode javascript callbacks, you have
            to pass the option <code>'enableJsonExprFinder' = true</code> into the
            <code>encode</code> function. If enabled the expression support works for all nested
            expressions in large object structures. A usage example would look like:
        </para>

        <programlisting language="php"><![CDATA[
$data = array(
    'onClick' => new Zend_Json_Expr('function() {'
              . 'alert("I am a valid javascript callback '
              . 'created by Zend_Json"); }'),
    'other' => 'no expression',
);
$jsonObjectWithExpression = Zend_Json::encode(
    $data,
    false,
    array('enableJsonExprFinder' => true)
);
]]></programlisting>
    </sect2>
</sect1>