Introduction et Concepts

de base

1
 1. Origine et objectifs
• XML est issu de la Gestion de Documents (GED)
• Séparation du fond de la forme.
– Forme = présentation à partir de la structure (style)
– Fond = structure + données (contenu)
• Multiples précurseurs dont les plus connues :
– SGML pour la structuration
– HTML pour la présentation
– Approches mélangeant parfois le fond et la forme !

2
Origines
 Présentation et Structuration
Titre XML: Des BD aux Services Web

Auteur Georges Gardarin

Section 1. Introduction
Paragraphe Ces dernières années ont vu l'ouverture des systèmes
d'information à l'Internet. Alors que depuis les années
1970, ces systèmes se développaient, le choc Internet …

Ainsi, on a vu apparaître une myriade de technologies

Paragraphe nouvelles attrayantes mais peu structurantes voir
perturbantes. Certaines n'ont guère survécues …

L'urbanisation passe avant tout par la standardisation des

échanges : il faut s'appuyer sur des standards ouverts,
solides, lisibles, sécurisés, capable d'assurer
Paragraphe l'interopérabilité avec l'Internet et les systèmes
d'information …

2. La société ProXML

Section
3
Origines
 Vue Balisée
<Livre>
<Titre> XML : Des BD aux Services Web</Titre>
<Auteur>Georges Gardarin</Auteur>
<Section titre = "Introduction">
<Paragraphe>Ces dernières années ont vu l'ouverture des systèmes d'information à l'Internet. Alors que
depuis les années 1970, ces systèmes se développaient, le choc Internet … </Paragraphe>
<Paragraphe>Ainsi, on a vu apparaître une myriade de technologies nouvelles attrayantes mais peu
structurantes voir perturbantes. Certaines n'ont guère survécues … </Paragraphe>
<Paragraphe>L'urbanisation passe avant tout par la standardisation des échanges : il faut s'appuyer sur
des standards ouverts, solides, lisibles, sécurisés, capable d'assurer l'interopérabilité avec l'Internet et
les systèmes d'information … </Paragraphe>
</Section>
<Section titre= "La Société ProXML"> …
</Section>
</Livre>
Les balises (tags) peuvent porter
plus ou moins de sémantique
4
Origines
 Forces de XML

• Séparation de la structure et de la présentation.

• Moins confus que HTML
• Plus simple que SGML
• Idéal pour l'échange de données semi-structurées
• Utilisable entre machines

5
Origines
 Pourquoi XML?
• Définir vos propres langages d’échange
– Commande, facture, bordereau de livraison, etc.
• Modéliser des documents et des messages
– Modèle logique de données
– Eléments typés agrégés (DTD, XML Schema)
– Passerelle avec Unified Modelling Language (UML)
• Publier des informations
– Neutre du point de vue format
– Mise en forme avec des feuilles de style
• Archiver des données
– Auto-description des archives

6
Pourquoi XML ?
 Publication multi-supports

Middleware
XMLizer XML Application de
publication
(XSL)

Base de
Données
TV Numérique
Projet GIE Cartes Bancaires:
publication des spécifications de protocoles pour réseau Carte Bancaires
vers les fournisseurs et prestataires du GIE 7
Pourquoi XML ?
 Forces et faiblesses de XML
• Une technologie structurante • Une syntaxe bavarde
• Clarifie tous les échanges • Un méta-langage, mais de nombreux
langages
• Des standards internes et
externes • Coûteux en CPU
– Parsing
• Transversale à l'entreprise
• Coûteux en mémoire
– Échanges de données
– Instanciation
– Bureautique
• Format compressé à l’étude
– GED
– Sites Web
– EDI
– Bases de données
– Intégration e-business
– …

8
 Bases de données vs XML
Approche « Donnée » Approche « Document »
 Structuration forte et simple  Structuration faible et complexe
 Compatibilité SGBDR existants  Systèmes documentaires
 Mise à jour en place spécialisés
 Intégrité sémantique  Gestion de versions
 Indexation exacte  Recherche textuelle
 Adapté au transactionnel et  Indexation approchée
décisionnel  Accès type moteur de recherche
 Performances attendues  Performances attendues
« moyenne » à « forte » pour « moyenne » pour une
une volumétrie « moyenne » volumétrie « forte »

9
XML: DÉFINITIONS DE BASE

10
 XML: définitions de base
• XML est un méta-langage universel pour représenter les données
échangées sur le Web qui permet au développeur de délivrer du
contenu depuis les applications à d'autres applications ou aux
navigateurs
• XML standardise la manière dont l'information est :
– échangée
– présentée
– archivée
– retrouvée
– transformée
– cryptée
– ...

11
XML
 Concepts
• Balise (ou tag ou label)
– Marque de début et fin permettant de repérer un élément textuel
– Forme: <balise> de début, </balise> de fin
• Elément de données
– Texte encadré par une balise de début et une de fin
– Les éléments de données peuvent être imbriquées
<producteur>
<adresse>
<rue>A. Briand</rue>
<ville>Dijon</ville>
</adresse>
</producteur>
• Attribut
– Doublet nom="valeur" qualifiant une balise
• <producteur no="160017" region="Bourgogne">
12
Exemple complet

13
 Présentation textuelle
<liste>
<Restaurant Type="Français" Categorie="***">
<Nom>Le Moulin de Mougin</Nom>
<Manager ... >Dupuis</Manager>
<Adresse>
<No> 7</No>
<Rue>Des Vignes</Rue>
<Ville>Mougin</Ville>
</Adresse>
</Restaurant>
…….
…….
…….
</liste>
14
XML
 Modèle arborescent
@Type Français

@Catégorie ***

Nom Le Moulin de Mougin

Restaurant
Manager Dupuis

No 7

Adresse Rue Des Vignes

Ville Mougin

15
XML
DTD: Document Type Definition

16
 Modélisation des documents:
DTD et Schéma
• Un document XML peut être associé à :
– une DTD ou un schéma pour décrire les balises
– Une feuille de style pour présenter les données
• Une DTD ou/et un schéma permettent de définir son
propre langage basé sur XML
– Vocabulaire (balises)
– Grammaire (imbrications)

17
 Validité des documents
Document bien formé (Well Formed document):
• Guillemets (ou apostrophes) obligatoires autour des valeurs
<adresse id=‘2’ type=‘domicile’/>
• Les éléments vides utilisent une notation spécifique
<image src=‘image3.gif’/> <image src=‘image3.gif’></image>
• Les balises doivent être correctement imbriquées
<b><i> NON ! </b></i>
• Le document a une seule racine
• Un attribut est unique dans son élément

Document valide (Valid document):

• bien formé + conforme à la DTD ou au schéma qui lui est associé
18
 Validité des documents
Document bien formé (Well Formed document):
• Guillemets (ou apostrophes) obligatoires autour des valeurs
<adresse id=‘2’ type=‘domicile’/>
• Les éléments vides utilisent une notation spécifique
<image src=‘image3.gif’/> <image src=‘image3.gif’></image>
• Les balises doivent être correctement imbriquées
<b><i> NON ! </b></i>
• Le document a une seule racine
• Un attribut est unique dans son élément

Document valide (Valid document):

• bien formé + conforme à la DTD ou au schéma qui lui est associé
19
 Modélisation des documents:
DTD et Schéma
• Un document XML peut être associé à :
– une DTD ou un schéma pour décrire les balises
– Une feuille de style pour présenter les données
• Une DTD ou/et un schéma permettent de définir son
propre langage basé sur XML
– Vocabulaire (balises)
– Grammaire (imbrications)

20
 Validité des documents
Document bien formé (Well Formed document):
• Guillemets (ou apostrophes) obligatoires autour des valeurs
<adresse id=‘2’ type=‘domicile’/>
• Les éléments vides utilisent une notation spécifique
<image src=‘image3.gif’/> <image src=‘image3.gif’></image>
• Les balises doivent être correctement imbriquées
<b><i> NON ! </b></i>
• Le document a une seule racine
• Un attribut est unique dans son élément

Document valide (Valid document):

• bien formé + conforme à la DTD ou au schéma qui lui est associé
21
 DTD
• Permet de définir le «vocabulaire» et la structure qui
seront utilisés dans le document XML
• Grammaire du langage dont les phrases sont des
documents XML (instances)
• Peut être mise dans un fichier (DTD externe) et être
appelée dans le document XML

22
 Déclaration d'élément simple
<! ELEMENT balise (définition) >
– Le paramètre définition représente soit un type de donnée
prédéfini, soit un élément de données composé, constitué lui
même d'éléments
– Types prédéfinis:
• ANY : L'élément peut contenir tout type de donnée
• EMPTY : L'élément ne contient pas de données spécifiques
• #PCDATA : L'élément doit contenir une chaîne de caractère

Exemple:
<! ELEMENT Nom (#PCDATA)>
 <Nom>Victor Hugo</Nom>
23
 Déclaration d'élément composé
Définit une séquence ou un choix d'éléments
Syntaxe spécifique avec opérateurs de composition
d'éléments :
<! ELEMENT balise (composition) >

24
 Exemple d'élément composé
<!ELEMENT personne (nom, <personne>
prenom+, tel?, adresse) > <nom>Hugo</nom>
<!ELEMENT nom (#PCDATA) > <prenom>Victor</prenom>
<!ELEMENT prenom (#PCDATA) > <prenom>Charles</prenom>
<!ELEMENT tel(#PCDATA) > <tel>01120243</tel>
<!ELEMENT email (#PCDATA) > <adresse>
<!ELEMENT adresse (ANY) > <rue></rue>
<ville>Paris</ville>
</adresse>
</personne>

25
 Déclaration d'attributs
<! ATTLIST balise Attribut Type contrainte>
– balise: spécifie l'élément auquel est attaché l'attribut
– Attribut: est le nom de l'attribut déclaré
– Type: définit le type de donnée de l'attribut choisi parmi:
– CDATA: Chaînes de caractères entre guillemets ("aa") non
analysées
– Enumération:
– Liste de valeurs séparées par |
– <! ATTLIST balise Attribut (Valeur1 | Valeur2 | ... ) >

26
 Déclaration d'attributs

– contrainte : définit les contraintes que doit respecter l’attribut, n’est pas
obligatoire

• #REQUIRED : l’attribut est obligatoire

• #IMPLIED : l’attribut est optionnel
• #FIXED : la valeur de l’attribut est fixé, et prends comme valeur la valeur
par défaut

27
 Déclaration d'attributs
• Un attribut peut être déclaré comme identifiant d’un élément avec le mot clé ID

• Un attribut peut être déclaré comme référence vers un autre élément (clé étrangère) avec
le mot clé IDREF

28
 Exemple
• <! ATTLIST personne
num ID,
age CDATA,
genre (Masculin | Feminin ) >
<!ELEMENT auteur (#PCDATA) >
<!ELEMENT editeur (#PCDATA) >
<!ATTLIST auteur
genre (Masculin | Feminin ) #REQUIRED
ville CDATA #IMPLIED>
<!ATTLIST editeur
ville CDATA #FIXED "Paris">
29
 Utiliser une DTD

• DOCTYPE permet de déclarer la DTD à utiliser pour valider le document

XML,

– vient directement après l’entête

– balise-racine : l’élément XML qui sera la racine (root) du document XML

30
 Utiliser une DTD interne

• La DTD est déclaré directement dans le document XML dans la balise

DOCTYPE

31
 Utiliser une DTD externe
• La DTD est déclaré dans un fichier externe

– SYSTEM : la DTD est indiqué en fournissant sa location par son URI

– PUBLIC : la DTD est dans le domaine public (norme), indiqué par son identifiant (FPI)
et sa location par son URI

32
 Les entités
• Mécanisme qui permet de déclarer un alias vers une information qui va être réutilisé
dans un XML ou une DTD
– entité générale : utilisé dans le document XML

– entité paramètre : utilisé dans une DTD

– entité externe : même rôle que l’entité générale, sauf que les informations sont stockés dans un
fichier externe

• L’attribut standalone au niveau de l’entête doit être a no

33
 Exercice
• On se propose de définir un format XML de stockage d’un
catalogue de films sur DVD.
• Le catalogue comprend un ensemble de fiches de films
• Chaque fiche comprend:
– Un numéro unique
– Le titre du film
– Un ou plusieurs réalisateurs
– Un ou plusieurs éditeurs
– Les acteurs principaux
– Le genre du film (comédie, horreur, action…) (en option)
– Un commentaire optionnel qui présente brièvement l’histoire du
film
– Un lien éventuel vers le site du film

34
 Corrigé
<?xml version="1.0" encoding="ISO-8859-1"?>
<!--premier niveau: cataloque -->
<!ELEMENT cataloguedvd (fiche)*>
<!--deuxième niveau: fiche -->
<!ELEMENT fiche (titre, technique,commentaire?,internet?)>
<!ATTLIST fiche genre (Horreur|Action|comédie|inconnu) #IMPLIED
numero CDATA #REQUIRED>
<!--troisième niveau: sous éléments de ‘fiche’ -->
<!ELEMENT titre (#PCDATA)>
<!ELEMENT commentaire (#PCDATA)>
<!ELEMENT internet (#PCDATA)>
<!ELEMENT technique (realisateur+,editeur+,acteur*)>
<!--quatrième niveau: sous éléments de ‘technique’ -->
<!ELEMENT realisateur (#PCDATA)>
<!ELEMENT editeur (#PCDATA)>
<!ELEMENT acteur (#PCDATA)>
35
 Quelques règles d'écriture
• Modularité
– définir dans des entités séparées les parties réutilisables
• Précédence
– Regrouper les déclarations d'entités en tête
• Abstraction
– Utiliser des entités pour les modèles de contenus
• Spécificité
– Éviter les DTD trop générales
• Simplicité
– Découper les DTD trop complexes

36
DTD
 Insuffisance des DTD
• Pas de types de données
– difficile à interpréter par le récepteur
– difficile à traduire en schéma objets
• Pas en XML
– langage spécifique
• Propositions de compléments
– XML-data de Microsoft (BizTalk)
– XML-schema du W3C

37
 XML Schéma (xsd)
• Un schéma d'un document définit:
– les éléments possibles dans le document
– les attributs associés à ces éléments
– la structure du document
– les types de données
• Le schéma est spécifié en XML
– pas de nouveau langage
– balisage de déclaration
– espace de nom spécifique xsd: ou xs:
• Présente de nombreux avantages
– structures de données avec types de données
– extensibilité par héritage et ouverture
– analysable à partir d'un parseur XML standard
38
 Objectifs des schémas
• Reprendre les acquis des DTD
– Plus riche et complet que les DTD
• Permettre de typer les données
– Eléments simples et complexes
– Attributs simples
• Permettre de définir des contraintes
– Existence, obligatoire, optionnel
– Domaines, cardinalités, références
– Patterns, ...
• S'intégrer à la galaxie XML
– Espace de noms
– Infoset (structure d'arbre logique)

39
 Les types XML
La base d’un schéma XML: l’élément
<xs:element name="…" type="…"/>
• Un élément peut avoir un type:
– Simple si sa valeur a un type prédéfini en XML-SCHEMA
(xs:string, xs:int, xs:decimal, xs:double…) ou une extension
de ces types
– Complexe s’il contient des sous éléments ou s’il comporte un
attribut
• xs:all tous les éléments doivent exister (peu importe l’ordre)
• xs:choice un des éléments doit exister
• xs:sequence tous les éléments doivent exister dans l’ordre spécifié

40
 Modèles de contenu et types
• Quatre catégories de modèles de contenu

• Deux catégories de types de données: simple et complexe

41
 Commandes de base xsd:
• element : association d'un type à une balise
– attributs name, type, ref, minOccurs, maxOccurs, ...

• attribute : association d'un type à un attribut

– attributs name, type

• type simple : les multiples types de base

– entier, réel, string, time, date, ID, IDREF, …,
– extensibles par des contraintes

• type complexe : une composition de types

– définit une agrégation d'éléments typés

42
Schema
 Les types simples (1)
• string • integer
– Confirm this is electric – -126789, -1, 0, 1, 126789
• normalizedString • positiveInteger
– Confirm this is electric – 1, 126789
• token • negativeInteger
– Confirm this is electric – -126789, -1
• byte • nonNegativeInteger
– -1, 126 – 0, 1, 126789
• unsignedByte • nonPositiveInteger
– 0, 126 – -126789, -1, 0
• base64Binary • int
– GpM7 – -1, 126789675
• hexBinary • unsignedInt
– 0FB7 – 0, 1267896754

43
Schema
 Les types simples (2)
• long • boolean
– -1, 12678967543233 – true, false 1, 0
• unsignedLong • time
– 0, 12678967543233 – 13:20:00.000, 13:20:00.000-05:00
• short • dateTime
– -1, 12678 – 1999-05-31T13:20:00.000-05:00
• unsignedShort • duration
– 0, 12678 – P1Y2M3DT10H30M12.3S
• decimal • date
– -1.23, 0, 123.4, 1000.00 – 1999-05-31
• float • gMonth
– -INF, -1E4, -0, 0, 12.78E-2, 12, INF, NaN – --05--
• double • gYear
– -INF, -1E4, -0, 0, 12.78E-2, 12, INF, NaN – 1999

44
Schema
 Les types simples (3)
• gYearMonth • language
– 1999-02 – en-GB, en-US, fr
• gDay
– ---31
• ID
– "A212"
• gMonthDay
– --05-31 • IDREF
• Name – "A212"
– shipTo • IDREFS
• QName – "A212" "B213"
– po:USAddress
• ENTITY
• NCName
– USAddress • ENTITIES
• anyURI • NOTATION
– http://www.example.com/,
– http://www.example.com/doc.html#ID5
• NMTOKEN, NMTOKENS
– US
– Brésil Canada Mexique

45
Schema
 Les types complexes
• Définition d'objets complexes
– <sequence> : collection ordonnée d'éléments typés
– <all> : collection non ordonnée d'éléments typés
– <choice>: choix entre éléments typés
• Exemple
<xsd:complexType name="AddresseFR">
<xsd:sequence>
<xsd:element name="nom" type="xsd:string"/>
<xsd:element name="rue" type="xsd:string"/>
<xsd:element name="ville" type="xsd:string"/>
<xsd:element name="codep" type="xsd:decimal"/>
</xsd:sequence>
<xsd:attribute name="pays" type="xsd:NMTOKEN" fixed="FR"/>
</xsd:complexType>
46
Schema
 Héritage de types
• Définition de sous-types • Exemple :
<complexType name="AdressePays">
par héritage
<complexContent>
– Par extension : ajout
<extension base="Adresse">
d'informations
<sequence>
– Par restriction : ajout de
<element name="pays" type="string"/>
contraintes
</sequence>
</extension>

• Possibilité de contraindre </complexContent>

</complexType>
la dérivation

47
 Les patterns
• Contraintes sur type simple prédéfini
• Utilisation d'expression régulières
• Exemple
<xsd:simpleType name="NumItem">
<xsd:restriction base="xsd:string">
<xsd:pattern value="\d{3}-[A-Z]{2}"/>
</xsd:restriction>
</xsd:simpleType>
Autres facettes de restriction
- xs:mininclusive, xs:maxexclusive, xs:enumeration,
xs:length…
48
Schema
 Réutilisation de types
• Type simple avec extension
<xs:simpleType name="num5">
<xs:restriction base="xs:string">
<xs:pattern value="\d{5}"/>
</xs:restriction>
</xs:simpleType>

• Type complexe (séquence)

<xs:element name="livre">
<xs:complexType>
<xs:sequence>
<xs:element name="Titre" type="xs:string"/>
<xs:element name="Auteur" type="xs:string"/>
<xs:element name="ISBN" type="num5"/>
</xs:sequence>
</xs:complexType>
</xs:element>
49
 Réutilisation du types
• Une bibliothèque contient au moins un livre

<xs:element name="biblio">
<xs:complexType>
<xs:sequence>
<xs:element ref="livre" minOccurs= " 1 "
maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>

50
 attribut
• La définition d’attributs associés à un élément se fait dans par la
balise <attribute>.
– name : nom de l’attribut
– type : type de l’attribut, ne peut être qu’un type simple.
– use : permet de préciser si l’attribut est obligatoire, optionnel ou
interdit. Valeurs possibles :
• required : obligatoire
• optional : optionnel
• prohibited : interdite
– fixed : valeur fixe, ne change pas
– default : valeur par défaut.

51
 attribut
• La définition d’attributs peut se faire de deux façons différents.
– Définir l’attribut et l’utiliser dans la définition du type.
– Définir l’attribut directement à l’intérieur du type.

52
 Groupage d’éléments
<xs:group name="TitreAuteurISBN">
<xs:sequence>
<xs:element name="Titre" type="xs:string"/>
<xs:element name="Auteur" type="xs:string"/>
<xs:element name="ISBN" type="num5"/>
</xs:sequence>
</xs:group>
<xs:element name="livre">
<xs:complexType>
<xs:sequence>
<xs:group ref="TitreAuteurISBN"/>
<xs:element ref="traduction"/>
</xs:sequence>
</xs:complexType>
</xs:element>

53
 Référence à un Schéma XML
• Référence sans espace de noms

• Référence avec espace de noms

54
 XML Schema : exemple (1)
<xsd:schema
xmlns:xsd="http://www.w3.org/1999/XMLSchema">
<xsd:element name="commande" type="CommandeType"/>
<xsd:element name="commentaire" type="xsd:string"/>
<xsd:complexType name="CommandeType">
<xsd:sequence>
<xsd:element name="livrer" type="Adresse"/>
<xsd:element name="facturer" type="Adresse"/>
<xsd:element ref="commentaire" minOccurs="0"/>
<xsd:element name="produits" type="ProduitType"/>
</xsd:sequence>
<xsd:attribute name="date_com" type="xsd:date"/>
</xsd:complexType>

55
Schema
 XML Schema : exemple (2)
<xsd:complexType name="ProduitType">
<xsd:sequence>
<xsd:element name="produit" minOccurs="0" maxOccurs="unbounded">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="nom_prod" type="xsd:string"/>
<xsd:element name="quantite">
<xsd:simpleType> <xsd:restriction base="xsd:positiveInteger">
<xsd:maxExclusive value="100"/> </xsd:restriction>
</xsd:simpleType>
</xsd:element>
<xsd:element name="prix" type="xsd:decimal"/>
<xsd:element ref="commentaire" minOccurs="0"/>
<xsd:element name="date_livraison" type="xsd:date" minOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="num_prod" type="xsd:positiveInteger" use="required"/>
</xsd:complexType>
</xsd:element>
</xsd:sequence> </xsd:complexType> </xsd:schema>

56
Schema
Présentation et transformations de
documents

57
 Formatage de document XML
• Un document et sa DTD ou schéma ne donnent pas d’indications
sur sa représentation.
– Une description supplémentaire est nécessaire:
• DSSSL: Document Style Semantics and Specification language
• CSS: Cascading StyleSheets
• XSL:eXtensible Stylesheet Language

58
 Faiblesses de CSS
• CSS a été initialement prévu pou la présentation
des documents HTML
• Même défauts que HTML
- Syntaxe non modifiable et non extensible
- Syntaxe difficile à normaliser
- Difficultés pour trouver des éléments

59
 Manipulation des documents XML
• La manipulation des données XML peut se faire de deux manières :

1. en utilisant le standard dérivé XSL, une spécification composée de

trois parties : XSL-FO, XSLT, XPATH;
2. ou avec des langages de programmation qui utilisent des APIs
(Application Programming Interface) basées sur les modèles DOM
et SAX.

60
 Le standard XSL
Par sa conception, XML sépare un document proprement dit de sa
grammaire, de son format d'affichage et de ses mécanismes
d'hyperliens.
Nous présentons dans cette section le langage XSL qui est, le
standard associé à XML le plus utilisé. XSL (eXtensible Style
Language) est une spécification composée de trois parties :
– XPATH pour la sélection de nœuds (éléments ou attributs) dans
un document XML, XPATH est utilisé par XSLT ;
– XSLT (XSL Transformation) pour la réorganisation des documents
XML ;
– et XSL-FO (XSL Formatting Objects) pour la présentation en ligne
des documents XML (formatage vers HTML).

61
 XPATH
• XPATH est un langage qui permet d’identifier un nœud (élément ou attribut) dans un
document XML selon certains critères, par exemple son nom. Les critères sont
spécifiés à l’aide de sélecteurs. La syntaxe de base ressemble à l’adressage dans un
système de fichiers.
• Exemple:
Pour accéder à la liste des nœuds TITRE du document XML la syntaxe de la requête
est : /BIBLIO/LIVRE/AUTEUR/TITRE
Un parseur XPATH retournera la liste de nœuds suivante :
<TITRE>XML, Langage et Applications</TITRE>
<TITRE>HTML4, XML et Java 2</TITRE>
Cette requête obéit à la règle d’accès /a/b dont le rôle est de fournir la liste des
éléments dont le chemin dans l’arborescence XML correspond à la requête.
Si b est un attribut, il faut ajouter le signe @ devant. Pour accéder par exemple aux
nœuds ISBN du document précédent, la syntaxe est :
/BIBLIO/LIVRE/@ISBN Cette règle admet plusieurs variantes basées sur l’utilisation
de sélecteurs. Les sélecteurs les plus usuels sont :

62
 XPATH
Les sélecteurs les plus usuels sont :
-// qui permet de ne pas tenir compte de la profondeur de l’élément dans
l’arborescence ;
avec la requête //TITRE, on obtiendrait le même résultat qu’avec
/BIBLIO/LIVRE/AUTEUR/TITRE.
-[Position] permettant un accès sélectif ; avec la requête /BIBLIO/LIVRE[1]/TITRE, on
obtiendrait que le nœud TITRE du 1er élément LIVRE.
- * qui fournit tous les éléments fils de la sélection ; par exemple la requête
//BIBLIO/LIVRE[1]/* fournit tous les nœuds du 1er élément LIVRE.

63
 XPATH
• Certains des sélecteurs sont utilisés sous forme de prédicats; c’est-à-dire
d’expressions booléennes mises entre crochets "[ ]". Ils permettent d’effectuer
un tri sur des éléments obtenus par une requête simple.
• On peut ainsi effectuer un test sur le nom d’un élément, son contenu, ses
attributs, sa position dans l’arbre XML, etc.
• Par exemple:
pour rechercher le titre du livre dont le numéro ISBN vaut 2-212-09052-8, on
peut utiliser le prédicat de la forme @attribut=valeur et obtenir la requête
suivante : /BIBLIO/LIVRE/[@ISBN="2-212-09052-8"]/TITRE
• XPATH permet aussi d’exprimer des requêtes plus complexes en introduisant des
fonctions.
• Il est possible par exemple de rechercher un élément dont la valeur contient une
chaîne de caractères avec les fonctions text() (donne la valeur d’un élément) et
contains() (teste si une sous-chaîne appartient à une chaîne).
• La requête suivante cherche tous les livres dont le titre contient "XML" :
/BIBLIO/LIVRE/TITRE[contains(text(), ‘XML’)]
64
 XSLT
• XSLT est un langage déclaratif permettant de transformer un document XML en
un autre document XML, HTML ou texte. Un processeur XSLT lit un document
XML et un document XSLT (appelée feuille de style XSLT) et génère un nouveau
document.

65
XSLT
Structure

66
 XSLT
Structure

• La racine d’un document XLST est la balise <stylsheet>

– Indique la version à utiliser et le namespace XSLT
http://www.w3.org/1999/XSL/Transform

• La balise <transform> peut aussi être utilisé comme racine

67
 XSLT
Templates

• Le processeur XSLT fait subir au document XML des transformations selon

des modèles de transformation (template) décrits dans la feuille XSL pour
produire un nouveau document selon le type de sortie souhaité.

• Chaque modèle de transformation définit des traitements à effectuer sur un

élément ou un ensemble d’éléments du document XML source.

• Un modèle est représenté par la balise <template> dans la feuille XSL

• Une feuille XSL peut contenir plusieurs modèles

68
 XSLT
Templates

 La balise template définit un modèle de transformation.

 match : permet de sélectionner des éléments du document XML
sur lesquels sera appliqué la transformation

 name : nom du modèle, il permet de faire appel au modèle

directement sans passer par l’évaluation des nœuds du document
<xsl:call-template>

 priority : priorité du modèle, utilisé si le processeur XSLT identifie

plusieurs modèles de transformation pour le même noeud
69
 XSLT
Templates

• Le contenu de la balise template représente les règles de transformation à

appliquer sur les éléments sélectionnés par l’expression du match

70
 XSLT
Templates

• La balise <apply-templates> permet de demander au processeur XSLT

d’appliquer un modèle définie et qui correspond à l’expression XPath fournit
par son attribut select
– select : sert à identifier les modèles qui vont être appliqués, la
correspondance est effectué sur la base de l’attribut match du modèle
– Si select n’est pas fourni, le modèle est appliqué sur tous les fils du
nœud courant.

• Dans le cas où plusieurs modèles correspondent à l’expression select: Il faut

donc:
– Utilisation de l’attribut priority du modèle
– Utilisation du modèle dont l’expression match est la plus spécifique

71
XSLT
Templates

72
 XSLT
Logique : boucle

• <for-each> permet d’effectuer une boucle sur les éléments qui correspondent au
résultat de l’expression XPath de l’attribut select

73
 XSLT
Logique : traitement conditionnel

• <if> permet d’effectuer un traitement conditionnel si le résultat de

l’expression de l’attribut test est vrai
– L’expression test accepte la même syntaxe que les prédicats XPath.

74
 XSLT
Logique : traitement conditionnel

• <choose> permet de faire un choix parmi plusieurs alternatives.

– <when>, traitement a effectuer si l’expression test est vrai
– <otherwise>, traitement a effectuer si aucune condition <when> n’est réalisé

75
 XSLT
Logique : ordonnancement

• <sort> permet d’effectuer l’ordonnancement d’un ensemble d’éléments

• <sort> vient comme fils d’un <template> ou d’un <for-each> pour en ordonner
les éléments
– select : expression qui sert de critère de tri
– data-type : text ou number ,spécifie le type de tri
– order : ascending ou descending
– case-order : upper-first ou lower-first

76
 XSLT
Génération de contenu XML

• <copy> fournit un moyen simple pour copier le noeud courant dans la sortie
– use-attribute-sets : les attributs du nœud qui seront copiés, si vide tous.
– <copy> ne copie pas les enfants du nœud
• <element> permet de créer un élément XML dans la sortie
– name : nom local de l’élément
– use-attribute-sets : es attributs du nœud qui seront associés à l’élément.
• <attribute> utilisé en association avec <element> pour y ajouter un attribut
– name : nom de l’attribut

77
 XSLT
Sortie

• La balise <output> est le 1er fils de la racine du document XSLT, cette

balise indique :
– method : le format de sortie xml, html ou texte.
– doctype-public : est le nom du standard respecté par la sortie.
– doctype-system : est le lien vers la DTD de ce standard.
– indent=yes : indique que le fichier généré sera automatiquement indenté.
• désactiver l'indentation diminue la taille des fichiers générés.

78
 Exemple
Considérons le document XML et le document XSLT suivant, que nous pouvons considérer comme la définition
d’une vue (ou requête) sur ledit document:
<BIBLIO>
<LIVRE ISBN= “2-212-09052-8” LANG= “FR”>
<AUTEUR>
<NOM>Michard</NOM>
<PRENOM>Alain</PRENOM>
</AUTEUR>
<TITRE>XML, Langage et Applications</TITRE>
<EDITEUR>Eyrolles</EDITEUR>
<DATE_ACHAT>1998</DATE_ACHAT>
<PRIX monnaie= “FF”>340</PRIX>
</LIVRE>
<LIVRE ISBN= “2-7440-0628-9” LANG= “FR”>
<AUTEUR>
<NOM>Ladd</NOM>
<PRENOM>Eric</PRENOM>
</AUTEUR>
<AUTEUR>
<NOM>O’Donnel</NOM>
<PRENOM>Jim</PRENOM>
</AUTEUR>
<TITRE>HTML4, XML et Java 2</TITRE>
<EDITEUR>Campus Press</EDITEUR>
<PRIX monnaie= “FF”>349</PRIX>
</LIVRE>
</BIBLIO> 79
 Exemple
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output method="xml" indent="yes"/>
<xsl:template match="/">
<LIVRES>
<xsl:for-each select="BIBLIO/LIVRE">
<LIVRE>
<ISBN> <xsl:apply-templates select="@ISBN"/></ISBN>
<TITRE> <xsl:apply-templates select="TITRE"/></TITRE>
<xsl:for-each select="AUTEUR">
<AUTEUR> <xsl:apply-templates select="NOM"/>,
<xsl:apply-templates select="PRENOM"/>
</AUTEUR>
</xsl:for-each>
<EDITEUR> <xsl:apply-templates select="EDITEUR"/></EDITEUR>
</LIVRE>
</xsl:for-each>
</LIVRES>
</xsl:template>
</xsl:stylesheet>
80
 Exemple
L’exécution de cette vue sur ledit document permet d’obtenir le document XML suivant :

<LIVRES>
<LIVRE>
<ISBN>2-212-09052-8</ISBN>
<AUTEUR>Michard, Alain</AUTEUR>
<TITRE>XML, Langage et Applications</TITRE>
<EDITEUR>Eyrolles</EDITEUR>
</LIVRE>
<LIVRE>
<ISBN>2-7440-0628-9</ISBN>
<AUTEUR>Ladd, Eric</AUTEUR>
<AUTEUR>O’Donnel, Jim</AUTEUR>
<TITRE>HTML4, XML et Java 2</TITRE>
<EDITEUR>Campus Press</EDITEUR>
</LIVRE>
</LIVRES>

81
 XQuery
Définition

• XQuery pour XML Query

• C’est un langage de requête permettant d'extraire des informations

d'un document XML, ou d'une collection de documents XML

• XQuery joue par rapport aux données XML un rôle similaire à celui du
langage SQL vis-à-vis des données relationnelles

82
 XQuery
Syntaxes

• La syntaxe FLWR dont le nom vient des cinq clauses principales qui la composent
(for, let, where, et return)

• La syntaxe XQueryX pour « XML Syntax for XQuery », dans laquelle une requête
est un document XML.

• XQuery se base sur XPath pour sélectionner les éléments à traiter

83
 XQuery
Clause LET

• Une expression FLWOR permet d’utiliser des affectations de variables, et

d’utiliser ces variables dans la suite de la requête.

• L’affectation se fait au moyen de la clause LET

– les variables sont ensuite non mutables.

LET $noms := document(“annuaire.xml”)//nom

RETURN
$noms

84
 XQuery
Clause FOR

• La clause For permet d’effectuer des itérations sur un ensemble de noeuds

obtenus dans une requête.

• A chaque itération un élément de cette liste est affecté à une variable de boucle,
et le traitement explicité dans le For est appliqué à cette variable.

FOR $element IN //entree

RETURN
$element/nom

85
 XQuery
Clause RETURN

• La clause RETURN permet d’envoyer une valeur de retour à chaque itération de la boucle FOR,

• La valeur de retour est concaténée à une variable de sortie, qui est renvoyée à l’utilisateur lors
de la dernière itération.

• RETURN ne provoque pas de sortie de la boucle For, le retour effectif à l’utilisateur se fait
uniquement lors de la dernière itération !

FOR $element IN //entree

RETURN $element/nom

Résultat :
<nom>Nom1</nom>
<nom>Nom2</nom>
<nom>Nom3</nom>

86
 XQuery
Clause WHERE

• La clause WHERE permet de filtrer les noeuds obtenus par la requête dans une clause For,
à la manière du WHERE SQL.

• Le contenu de la clause WHERE est une expression dont le résultat de l’évaluation est
booléen.
– il est possible d’utiliser des opérations logiques AND et OR.
– il est possible d’utiliser des expressions et fonctions XPath

FOR $element IN //entree

WHERE $ element /nom = “Harry Cover”
OR $ element /nom = “Paul Lafargue”
RETURN $element

87
 XQuery
Imbrication de requêtes

• XQuery permet d’imbriquer les requêtes.

LET $entrees:=//entree
RETURN
FOR $nom IN $entrees/nom
RETURN
$nom

Résultat :
<nom>Nom1</nom>
<nom>Nom2</nom>

88
 XQuery
Requêtes XQuery avancées

89
 Exemple 1 : XPath

• (Q1) Noms de tous les restaurants :

– collection(“Restaurants”)/Restaurant/Nom/text()

– collection(“Restaurants”)/Restaurant/Nom

90
 Exemple 2 et 3 : XPath +

• Expression régulière
Menu de tous les restaurants
– collection(“Restaurants”)//Menu

• Accès via index à attribut

Donnez le nom des menus du premier restaurant
– collection(“Restaurants”)/Restaurant[1]/Menu/@Nom

91
 Exemple 4 : Sélection
• Lister le nom des restaurants de Cabourg:
– collection(“Restaurants”)/Restaurant [Adresse/Ville= “Cabourg"] /Nom

– <resultat>
FOR $R IN collection("Restaurants")/Restaurant
WHERE $R/Adresse/Ville = “Cabourg”
RETURN {$R/Nom}
</resultat>

92
Langages de requêtes
 Exemple 5 : Jointure
• Lister le nom des Restaurants avec téléphone dans la rue de l'Hôtel Lutecia:

– FOR $R IN collection("Restaurants")/Restaurant,
$H IN collection("Hotels")/Hotel
WHERE $H//Rue = $R//Rue
AND $H//Nom = "Le Lutecia"
RETURN
<Result>
{$R/Nom}
{$R/Téléphone}
</Result>

93
 Exemple 6 : Restructuration d'arbre

• Construire une liste de restaurants par Ville

– FOR $c IN distinct(collection(“Restaurants”)/Restaurant//Ville)
RETURN
<Ville>{$c}</Ville>
<Restaurants>
FOR $r IN collection(“Restaurants”)/Restaurant
WHERE $r//Ville = $c
RETURN {$r}
<Restaurants>

94
 Exemple 7 : Imbrication
• Adresses des hotels dans des villes ayant des
restaurants trois étoiles

– FOR $h IN collection(“Hotels”)/Hotel
WHERE $h/Adresse/Ville IN
FOR $r IN collection(“Restaurants”)/Restaurant
WHERE $r/@categorie = "***"
RETURN {$r/Adresse/Ville/text()}
RETURN {$h/Adresse}
95
 Exemple 8 : Agrégat simple
• Combien de restaurants y-a-t-il en collection ?

LET $R := collection(“Restaurants”)/Restaurant
RETURN
<NombreRestaurant > count ($R)
</NombreRestaurant>

96
 Exemple 9 : Agrégat partitionné

• Lister le nom de chaque restaurant avec le prix

moyens des menus proposés
– FOR $r IN collection(“Restaurants”)//Restaurant
LET $a := avg(collection(“Restaurants”)//
[Restaurant = $r]//Menu/@Prix)
RETURN
<resultat>
{$r/Nom}
<avgPrix>{$a}</avgPrix>
</resultat> 97
 Exemple 10 : recherche textuelle

• Lister les bons restaurants de Paris

– FOR $r IN collection(“Restaurants”)//Restaurant
WHERE CONTAINS ($r/Comments, “Bon”)
OR CONTAINS ($r/Comments, “Excellent”)
AND $r/Adresse/Ville = “Paris”
RETURN $r/Nom

98
 Exemple 11 : ordre et désordre
• Lister les bons restaurants de Paris par ordre
alphabétique

FOR $r IN
unordered(collection(“Restaurants”)//Restaurant)
WHERE $r/Comments CONTAINS (“Excellent”, “Good”)
AND $r/Adresse/Ville = “Paris”
RETURN $r/Nom
SORTBY ($r/Nom DESCENDING)

99
 Exemple 12 : XML actif (AXP)
• Construire un document avec en-tête, titre, liste
restaurants peu chers, titre, liste restaurants chers
<XML_document>
<Very_Expensive_Restaurants>
<Title>List of very expensive restaurants</Title>
FOR $r IN collection(Restaurants”)//Restaurant
WHERE EVERY p in $r/Menu/@Prix SATISFIES (p>100)
RETURN
{$r}
</Very_Expensive_Restaurants>
<Very_Inexpensive_Restaurants>
<Title>List of very inexpensive restaurants</Title>
FOR $r IN collection(“Restaurants”)//Restaurant
WHERE SOME p in $r/Menu/@Prix SATISFIES (p<10)
RETURN
{$r}
<Date>{date()}</Date>
</Very_Inexpensive_Restaurants>
</XML_document>

100
 Bilan XQuery
• Véritable L4G XML
• Très puissant
– Restriction
– Projection
– Jointure
– Imbrication
– Restructuration
– Agrégation
– Tri
– Quantificateurs
– Mots-clés
– …
• Sur des forêts dont les arbres sont des documents

101
Programmation en utilisant XML

102
 XML et langages de programmation
• Comment résoudre le problème de la distance entre XML et les
programmes objets?
- On peut manipuler les données XML grâce à des analyseurs de
documents appelés parseurs et qui ont en charge l’interprétation et
le traitement des documents XML.
- Il existe un certain nombre de parseurs disponibles sous forme
d’APIs.
- Les API XML sont : des librairies proposant un ensemble de
composants logiciels facilitant la lecture, la génération et le
traitement de documents XML.

103
 XML et langages de programmation
Ces API sont implémentées sur la base de 2 modèles :
• Le DOM XML (Document Objet Model) permettant la manipulation
d’un document XML après l’avoir représenté en mémoire sous la
forme d’un arbre d’objets.
• Le modèle SAX (Simple API for XML) permettant la manipulation
d’un document XML au fur et à mesure de la lecture de celui-ci.
L’extraction des données est basée sur une gestion d’événements
(création d’un document, d’un élément ...).

104
 Les parseurs XML
• SAX (Simple API for XML)
– Développement communautaire
– http://sax.sourceforge.net
• DOM (Document Object Model)
– Recommandation W3C
– http://www.w3.org/DOM/
• JAXP (Java API for XML Processing)
– Développement communautaire SUN
– http://java.sun.com/xml/jaxp
Couche d’abstraction de SAX, DOM et XSLT indépendante
de l’implémentation
 XML et JAVA = un couple parfait ☺

105
 SAX: Principe de fonctionnement
• SAX est une API permettant de lire un fichier XML sous forme de flux.
Le principe de fonctionnent est le suivant:
1. L'application crée un parseur et elle enregistre auprès de ce parseur son
gestionnaire d'événements.
2. Au cours de la lecture du fichier contenant le document XML, le gestionnaire
reçoit les événements générés par le parseur.
3. Le document XML n'est pas chargé en mémoire.
4. La tâche du programmeur est légère puisque le parseur est fourni par
l'environnement Java. Seul le gestionnaire d'événements doit être écrit par le
programmeur. Cette écriture est facilitée par les gestionnaires par défaut qu'il
est facile de dériver pour obtenir un gestionnaire.

106
SAX: Principe de fonctionnement

107
 DefaultHandler
• Le gestionnaire d'événements est en fait une classe qui implémente quatre
interfaces. Cette classe, qui s'appelle DefaultHandler peut être redéfinie par
héritage afin de gérer les événements qui nous intéressent.
• Voici un diagramme de classe de cette hiérarchie :

108
 Les méthodes essentielles de
DefaultHandler
• XMLReader • ErrorHandler
– setContentHandler – fatalError
– setErrrorHandler – Error
– Parse – Warning
• ContentHandler – EntityResolver
– startDocument – resolveEntity
– endDocument
– startElement
– endElement
– characters
109
Les méthodes essentielles de
DefaultHandler

110
Exemple de SAX

111
SAX: exemple d’utilisation

112
 DOM: Document Object Model
• Standard W3C fait pour HTML et XML
• Structure d'objets pour représenter un document
– Résultat d'un "parser"
– Arbre d'objets reliés entre eux
• Interface objet pour naviguer dans un document
– Orientée objet
– Peut être utilisée en:
• Java, C++
• C#, VB
• Python, PHP

113
DOM: Document Object Model

114
 DOM: Document Object Model
• DOM contient 12 types de nœuds différents.
• Le modèle d'objet de document fourni tout un ensemble d'outils destinés à
construire et manipuler un document XML. Pour cela, le DOM met à disposition
des interfaces, des méthodes et des propriétés permettant de gérer l'ensemble
des composants présents dans un document XML.
• Le DOM spécifie diverses méthodes et propriétés permettant notamment, de
créer (createNode…), modifier (replaceChild…), supprimer (remove…) ou
d'extraire des données (get…) de n'importe quel élément ou contenu d'un
document XML.
• De même, le DOM définit les types de relation entre chaque noeud, et des
directions de déplacement dans une arborescence XML. Les propriétés
parentNode, childNodes, firstChild, lastChild, previousSibling et nextSibling
permettent de retourner respectivement le père, les enfants, le premier enfant,
le dernier enfant, le frère précédent et le frère suivant du noeud courant.

115
Exemple d'arbre DOM

116
 Les Niveaux de DOM
• La spécification DOM level 1 (DOM niveau 1) se séparant en deux catégories:
– Core DOM level 1: La spécification pour les documents en général (dont XML)
– HTML DOM level 1: La spécification retenant uniquement les méthodes applicables à HTML.
• La spécification DOM level 2 ajoutant de nouvelles fonctionnalités comme la
prise en compte des feuilles de style CSS dans la hiérarchie d'objets

117
Lecture d’un document XML avec
DOM

118
 Org.w3c.dom.Document
• Interface qui représente une arborescence XML

119
 Org.w3c.dom.Element
• Interface représentant un élément XML

120
 Org.w3c.dom.Attr
• Interface représentant un attribut XML

121
 Exemple d'utilisation de DOM
Public class ExempleDOM
public static main (String argc[]) throws IOException, DOMExcetion
{
XMLDocument xmlDoc = new XmlDocument();
// creation des nœuds
ElementNode nom = (ElementNode) xmlDoc.createElement("nom");
ElementNode prenom = (ElementNode) xmlDoc.createElement("prenom");
ElementNode nomfam = (ElementNode) xmlDoc.createElement("nomfam");
// creation de l'arbre
xmlDoc.appendChild(nom); Document:
<nom ville ="Paris">
nom.appenChild(prenom); <prenom> Jean </prenom>
prenom.appendChild(xmlDoc.createTextNode("Jean"); <nomfa> Dupont </nomfa>
nom.appenChild(nomfam); </nom>

nomfam.appendChild(xmlDoc.createTextNode("Dupont");
// positionnement d'un attribut
nom.setAttribute("ville", "Paris");
// sortie
System.exit(0); }
122
 SAX Vs DOM

SAX DOM
Rapide Accès aléatoire au document
 Peu gourmand en mémoire Vue hiérarchique du document
 Accès séquentiel Permet de construire/modifier un
 Unidirectionnel au document document

123
 JSON
(JavaScript Object Notation)

124
 What is JSON?
• JSON is short for JavaScript Object Notation.
• JSON is a syntax for storing and exchanging data.
• JSON is an easier-to-use alternative to XML.
 How & When to use JSON

• Transfer data to and from a server

• Perform asynchronous data calls without

requiring a page refresh

• Working with data stores

• Compile and save form or user data for local

storage
 Why JSON?

Steps involved in exchanging data from web

server to browser involves:
Using XML
1. Fetch an XML document from web server.
2. Use the XML DOM to loop through the document.
3. Extract values and store in variables.
4. It also involves type conversions.

Using JSON
1. Fetch a JSON string.
2. Parse the JSON using JavaScript functions.
 Characteristics of JSON
• Lightweight, text-based open standard for data interchange
• It has been extended from the JavaScript language
• The extension of the file is .json
• The internet media type is application/json and the uniform type
identifier is public.json
• It is used when writing JavaScript based application which includes
browser extension and websites
• It is used for transmitting structured data over network connection
• Primarily used to transmit data between server and web application
• Easy to read and write and language independent

Note:
• Although JSON is an extension of JavaScript, it is also available in many
different languages such as: C, Ruby, Python, etc.
 JSON as an XML Alternative
• JSON = JavaScript Object Notation
– It’s really language independent
– most programming languages can easily read it and
instantiate objects or some other data structure
• JSON is a light-weight alternative to XML for data-
interchange
• Started gaining tracking ~2006 and now widely used
• http://json.org/ has more information
 XML vs JSON
• JSON is Like XML Because
– Both JSON and XML are "self describing" (human readable)
– Both JSON and XML are hierarchical (values within values)
– Both JSON and XML can be parsed and used by lots of programming languages

• JSON is Unlike XML Because

– JSON doesn't use end tag
– JSON is shorter
– JSON is quicker to read and write
– JSON can use arrays
– JSON has a better fit for OO systems than XML

• The biggest difference is:

– XML has to be parsed with an XML parser. JSON can be parsed by a standard JavaScript
function.
 Knocks against JSON

• Lack of namespaces

• No inherit validation (XML has DTD and

templates, but there is JSONlint)

• Not extensible

• It’s basically just not XML

 Example: XML vs JSON
<?xml version="1.0"?>
<employees>
<employee>
<firstName>John</firstName> <lastName>Doe</lastName>
</employee>
<employee>
<firstName>Anna</firstName> <lastName>Smith</lastName>
</employee>
<employee>
<firstName>Peter</firstName> <lastName>Jones</lastName>
</employee>
</employees>

{"employees":[
{ "firstName":"John", "lastName":"Doe" },
{ "firstName":"Anna", "lastName":"Smith" },
{ "firstName":"Peter", "lastName":"Jones" }
]}
 JSON Object Syntax
• Unordered sets of name/value pairs

• Begins with { (left brace)

• Ends with } (right brace)

• Each name is followed by : (colon)

• Name/value pairs are separated by , (comma)

 JSON Data – A name and a value

• A name/value pair consists of a field name (in double

quotes), followed by a colon, followed by a value
• Unordered sets of name/value pairs
• Begins with { (left brace)
• Ends with } (right brace)
• Each name is followed by : (colon)
• Name/value pairs are separated by , (comma)

{
"employee_id": 1234567,
"name": "Jeff Fox",
"hire_date": "1/1/2013",
"location": "Norwalk, CT",
"consultant": false
}
 JSON Data – A name and a value

• In JSON, values must be one of the following data types:

• a string
• a number
• an object (JSON object)
• an array
• a boolean
• null
{
"employee_id": 1234567,
"name": "Jeff Fox",
"hire_date": "1/1/2013",
"location": "Norwalk, CT",
"consultant": false
}
 JSON Data – A name and a value

• Strings in JSON must be written in double quotes.

{ "name":"John" }

• Numbers in JSON must be an integer or a floating point.

{ "age":30 }

• Values in JSON can be objects.

{
"employee":{ "name":"John", "age":30, "city":"New York" }
}

• Values in JSON can be arrays.

{
"employees":[ "John", "Anna", "Peter" ]
}
 Data Types: Strings

• Sequence of 0 or more Unicode characters

• Wrapped in "double quotes“

• Backslash escapement
 Data Types: Numbers
• Integer

• Real

• Scientific

• No octal or hex

• No NaN or Infinity – Use null instead.

 Data Types: Booleans & Null
• Booleans: true or false

• Null: A value that specifies nothing or no

value.
 eval
• The JavaScript eval(string) method compiles and
executes the given string
– The string can be an expression, a statement, or a
sequence of statements
– Expressions can include variables and object properties
– eval returns the value of the last expression evaluated
• When applied to JSON, eval returns the described
object
 JSON and—methods?
• In addition to instance variables, objects typically
have methods
• There is nothing in the JSON specification about
methods
• However, a method can be represented as a string,
and (when received by the client) evaluated with
eval
– Obviously, this breaks language-independence
– Also, JavaScript is rarely used on the server side
This is an example that shows creation of an object in
javascript using JSON : (Simple Objects)

<html>
<head>
<title>Creating Object JSON with JavaScript</title>

<script language="javascript" >

var JSONObj = { "name" : "tutorialspoint.com", "year" : 2005 };
document.write("<h1>JSON with JavaScript example</h1>");
document.write("<br>");
document.write("<h3>Website Name="+JSONObj.name+"</h3>");
document.write("<h3>Year="+JSONObj.year+"</h3>");
</script>

</head>
<body>

</body>
</html>
Now let's try to open file using IE or any other javascript enabled
browser. It produces the following result:
This is an example that shows creation of an object in
javascript using JSON : (Array Objects)

<html>
<head>
<title>Creation of array object in javascript using JSON</title>
<script language="javascript" >
document.writeln("<h2>JSON array object</h2>");
var books = {
"Pascal" : [
{ "Name" : "Pascal Made Simple", "price" : 700 },
{ "Name" : "Guide to Pascal", "price" : 400 }
],
"Scala" : [
{ "Name" : "Scala for the Impatient", "price" : 1000 },
{ "Name" : "Scala in Depth", "price" : 1300 }
]
}
var i = 0
document.writeln("<table border='2'><tr>");
for(i=0;i<books.Pascal.length;i++){
document.writeln("<td>");
document.writeln("<table border='1' width=100 >");
document.writeln("<tr><td><b>Name</b></td><td width=50>"
+ books.Pascal[i].Name+"</td></tr>");
document.writeln("<tr><td><b>Price</b></td><td width=50>"
+ books.Pascal[i].price +"</td></tr>");
document.writeln("</table>");
document.writeln("</td>");
}

for(i=0;i<books.Scala.length;i++){
document.writeln("<td>");
document.writeln("<table border='1' width=100 >");
document.writeln("<tr><td><b>Name</b></td><td width=50>"
 + books.Scala[i].Name+"</td></tr>");
document.writeln("<tr><td><b>Price</b></td><td width=50>"
+ books.Scala[i].price+"</td></tr>");
document.writeln("</table>");
document.writeln("</td>");
}
document.writeln("</tr></table>");
</script>
</head>
<body>
</body>
</html>
Now let's try to open file using IE or any other javascript enabled
browser. It produces the following result:
 Activity
• Convert the following bookstore.xml to bookstore.json
<?xml version="1.0"?>
<bookstore>
<book category="sci-fi">
<title lang="en"> 2001</title>
<author>Arthur C. Clarke</author>
<price>$30.0</price>
<year>1968</year>
</book>
<book>
<title lang="rs">Story about a True Man</title>
<author>Boris Polevoy</author>
<price>$20.00</price>
<year>1952</year>
</book>
</bookstore> 148