mozilla
Vos résultats de recherche

    JSON

    Résumé

    L’objet JSON contient des méthodes pour interpréter du JSON (JavaScript Object Notation) (voir également la page du glossaire JSON) et convertir des valeurs en JSON. Il ne peut être appelé ou construit, et, en dehors de ses deux méthodes, n’a pas de fonctionnalité propre.

    Description

    JavaScript Object Notation

    JSON est une syntaxe pour sérialiser des objets, tableaux, nombres, chaînes de caractères, booléens et valeurs null. Elle est basée sur la syntaxe de JavaScript mais en est distinct : du code JavaScript n’est pas nécessairement du JSON, et du JSON n’est pas nécessairement du JavaScript. Voir également : JSON : Le sous-ensemble de JavaScript qui n'en était pas vraiment un (en anglais).

    Différences entre JavaScript et JSON
    Type JavaScript Différences en JSON
    Objets et tableaux Les noms de propriété doivent être des chaînes de caractères délimitées par des guillements doubles ; les trailing commas sont interdits.
    Nombres Les zéros non significatifs sont interdits ; un point decimal doit être suivi d’au moins un chiffre.
    Chaînes de caractères

    Seul un jeu limité de caractères peut être échappé ; certains caractères de contrôle sont interdits ; le séparateur de ligne Unicode (U+2028) et le séparateur de paragraphe (U+2029) sont autorisés ; les chaînes de caractères doivent être délimitées par des guillements doubles. Voir l’exemple suivant où JSON.parse fonctionne correctement et une erreur de syntaxe (SyntaxError) est levée lors de l’évaluation du code comme du JavaScript :

    var code = '"\u2028\u2029"';
    JSON.parse(code); // Fonctionne
    eval(code); // Échoue

    La syntaxe complète du JSON est la suivante :

    JSON = null
        ou true ou false
        ou NombreJSON
        ou ChaîneJSON
        ou ObjetJSON
        ou TableauJSON
    
    NombreJSON = - NombrePositif
              ou NombrePositif
    NombrePositif = NombreDécimal
                  ou NombreDécimal . Chiffres
                  ou NombreDécimal . Chiffres PartiExposant
                  ou NombreDécimal PartiExposant
    NombreDécimal = 0
                 ou UnÀNeuf Chiffres
    PartiExposant = e Exposant
                ou E Exposant
    Exposant = Chiffres
            ou + Chiffres
            ou - Chiffres
    Chiffres = Chiffre
          ou Chiffres Chiffre
    Chiffre = 0 à 9
    UnÀNeuf = 1 à 9
    
    ChaîneJSON = ""
              ou " ChaîneCaractères "
    ChaîneCaractères = ChaîneCaractère
                    ou ChaîneCaractères ChaîneCaractère
    ChaîneCaractère = un caractère
                      sauf " ou \ ou U+0000 à U+001F
                   ou SéquenceÉchappement
    SéquenceÉchappement = \" ou \/ ou \\ ou \b ou \f ou \n ou \r ou \t
                  ou \u ChifreHexadécimal ChifreHexadécimal ChifreHexadécimal ChifreHexadécimal
    ChifreHexadécimal = 0 à 9
            ou A à F
            ou a à f
    
    ObjetJSON = { }
              ou { Membres }
    Membres = ChaîneJSON : JSON
           ou Membres , ChaîneJSON : JSON
    
    TableauJSON = [ ]
             ou [ ÉlémentsTableau ]
    ÉlémentsTableau = JSON
                 ou ÉlémentsTableau , JSON

    Des espaces blancs insignifiants peuvent être présents n’importe où sauf dans un JSONNumber (les nombres ne doivent pas contenir d’espaces blancs) ou dans un JSONString (where it is interpreted as the corresponding character in the string, or would cause an error). Les caractères tabulation (U+0009), retour chariot (U+000D), saut de ligne (U+000A), and espace (U+0020) sont les seuls caractères blancs valides.

    Méthodes

    JSON.parse()
    Interprète une chaîne de caractères comme du JSON, transformant de façon optionnelle la valeur produite et ses propriétés, puis retourne la valeur.
    JSON.stringify()
    Retourne une chaîne de caractères JSON correspondant à la valeur spécifiée, incluant de façon optionnelle seulement certaines propriétés, ou remplaçant des valeurs de propriété dans une forme définie par l’utilisateur.

    Prothèse d'émulation (polyfill)

    L’objet JSON n’est pas supporté par les anciens navigateurs. Il est possible de palier à ce problème en insérant le code suivant au début de vos scripts, permettant l’utilisation de l’objet JSON dans des implémentations qui ne le supportent pas nativement (comme Internet Explorer 6).

    L’algorithme suivant est une imitation de l’objet JSON natif :

    if (!window.JSON) {
      window.JSON = {
        parse: function(sJSON) { return eval('(' + sJSON + ')'); },
        stringify: (function () {
          var toString = Object.prototype.toString;
          var isArray = Array.isArray || function (a) { return toString.call(a) === '[object Array]'; };
          var escMap = {'"': '\\"', '\\': '\\\\', '\b': '\\b', '\f': '\\f', '\n': '\\n', '\r': '\\r', '\t': '\\t'};
          var escFunc = function (m) { return escMap[m] || '\\u' + (m.charCodeAt(0) + 0x10000).toString(16).substr(1); };
          var escRE = /[\\"\u0000-\u001F\u2028\u2029]/g;
          return function stringify(value) {
            if (value == null) {
              return 'null';
            } else if (typeof value === 'number') {
              return isFinite(value) ? value.toString() : 'null';
            } else if (typeof value === 'boolean') {
              return value.toString();
            } else if (typeof value === 'object') {
              if (typeof value.toJSON === 'function') {
                return stringify(value.toJSON());
              } else if (isArray(value)) {
                var res = '[';
                for (var i = 0; i < value.length; i++)
                  res += (i ? ', ' : '') + stringify(value[i]);
                return res + ']';
              } else if (toString.call(value) === '[object Object]') {
                var tmp = [];
                for (var k in value) {
                  if (value.hasOwnProperty(k))
                    tmp.push(stringify(k) + ': ' + stringify(value[k]));
                }
                return '{' + tmp.join(', ') + '}';
              }
            }
            return '"' + value.toString().replace(escRE, escFunc) + '"';
          };
        })()
      };
    }

    JSON2 et JSON3 sont de plus complexes et bien connus prohèses d'émulation (polyfills) pour l’objet JSON.

    Spécifications

    Spécification Statut Commentaires
    ECMAScript 5.1 (ECMA-262)
    La définition de 'JSON' dans cette spécification.
    Standard  
    ECMAScript 6 (ECMA-262)
    La définition de 'JSON' dans cette spécification.
    Projet  

    Compatibilité des navigateurs

    Fonctionnalité Chrome Firefox (Gecko) Internet Explorer Opera Safari
    Support simple (Oui) 3.5 (1.9.1) 8.0 10.5 4.0
    Fonctionnalité Android Chrome pour Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
    Support simple (Oui) (Oui) 1.0 (1.0) (Oui) (Oui) (Oui)

    Tableau basé sur le tableau de compatibilité de Kangax.

    Voir aussi

    Étiquettes et contributeurs liés au document

    Contributors to this page: Sheppy, teoli, SphinxKnight, wakka27
    Dernière mise à jour par : SphinxKnight,