Ok DTD XSD

VALIDATION D’UN FICHIER XML
Naoual ABDALLAH / DTD-XSD 1

SOMMAIRE
I. Les DTD (Document Type Definition)........................................................................3
1. Déclaration d'éléments :............................................................................................................3
2. Déclaration des attributs............................................................................................................5
3. Déclaration des entités..............................................................................................................6
II. Les schémas XSD (XML Schema Definition).............................................................8
1. Déclaration d'éléments simples :...............................................................................................9
2. Déclaration d'attributs :...........................................................................................................12
3. Déclaration d'éléments complexes :........................................................................................12
4. Configuration du nombre d'occurrences..................................................................................13

Pour être valide, un document XML doit respecter un ensemble de règles liées à son organisation et
à son contenu. Ces règles sont formulées dans une DTD (Document Type Definition) ou dans un
schéma XSD (XML Schema Definition).
I. Les DTD (Document Type Definition)

Les DTD peuvent être incorporées au fichier XML (dites internes) ou écrites dans des fichiers à
part (avec une extension .dtd) et donc accessibles à plusieurs fichiers XML (dites externes). Les
DTD externes peuvent être privées (reconnues juste sur la machine locale) ou publiques (indiquent
une ressource disponible pour tous sur un serveur distant).
o Déclaration d'une DTD interne :
< ?xml version="1.0" encoding="utf-8|ISO-8859-1" ?>
<!DOCTYPE Racine[
…
]>
o Déclaration d'une DTD externe locale

<!DOCTYPE Racine SYSTEM "Chemin_Relatif_Fichier">
o Déclaration d'une DTD externe publique

<!DOCTYPE Racine PUBLIC "Chemin_Pub lique_Fichier">
Dans une DTD interne les règles sont spécifiées entre les crochets. Dans une dtd externe les règles
sont spécifiées directement dans le fichier .dtd.
1. Déclaration d'éléments :
Pour déclarer un élément dans une DTD :
<!ELEMENT Nom_Elément (Type_Elément)>
Type_Element peut être :

o Du texte : Veut dire que l'élément contient une donnée (texte, nombre, date,…)
<!ELEMENT Nom_Elément (#PCDATA)>
Exemple d'élément de type texte :

<nom>Stylo</nom>
Règle correspondante :
<!ELEMENT nom (#PCDATA)>
o Une séquence d'éléments : Veut dire que l'élément se compose d'un ensemble de sous-
éléments qui doivent apparaitre dans l'ordre spécifié et selon l'occurrence indiquée.
<!ELEMENT Nom_Elément (Sous_Elément1occ, Sous_Elément2 occ,)
Occ peut prendre :

- Rien : apprait 1 et 1 seule fois ;
- ? : apparait 0 ou 1 fois
- + : apparaître 1 ou plusieurs fois
- * : apprait 0 ou plusieurs fois
Exemples d'éléments contenant des séquences d'éléments :

<fournisseur>
<code>C1</code>
<raisonsociale>Atlas</raisonsociale>
</fournisseur>
<produit>
<nom>Stylo</nom>
<prix>3</prix>
<fournisseur>
<code>C1</code>
</fournisseur>
<fournisseur>
<code>C2</code>
<raisonsociale>Amical</raisonsociale>
</fournisseur>
</produit>
<!ELEMENT fournisseur (code,raisonsociale)>
<!ELEMENT code (#PCDATA)>
<!ELEMENT raisonsociale (#PCDATA)>
<!ELEMENT produit (nom,prix,fournisseur+)>

<!ELEMENT prix (#PCDATA)>
o Un élément vide : Veut dire que l'élément ne contient ni du texte ni des sous-éléments mais il
peut contenir ou nom des attributs.
<!ELEMENT Nom_Elément EMPTY >
Exemples d'éléments vides :

<br/>
<transport type="x"/>
Règles correspondantes :
<!ELEMENT br EMPTY>
<!ELEMENT transport EMPTY>

o Une liste de choix d'éléments : offre le choix entre un ensemble de sous-éléments.
<!ELEMENT Nom_Elément (Sous_Elément1Choix1occ|
Sous_Elément1Choix2occ|Sous_Elément1Choix3occ,
Sous_Elément2occ,…)
Exemples d'éléments contenant des séquences d'éléments avec des choix :

<produit>
<nom>Stylo</nom>
<prix>3</prix>
<fournisseur>
<code>C1</code>
</fournisseur>
<fournisseur>
<code>C2</code>
<raisonsociale>Amical</raisonsociale>
<avantages niveau="4"/>
</fournisseur>
</produit>
<produit>
<designation>Scrabble</designation>
<prix>300</prix>
<fournisseur>
<code>C15</code>
<raisonsociale>Maxi</raisonsociale>
<avantages international niveau="2"/>
</fournisseur>
</produit>
Un produit a ou bien un nom ou bien une désignation
<!ELEMENT produit (nom|designation,prix,fournisseur+)>
<!ELEMENT designation (#PCDATA)>
<!ELEMENT prix (#PCDATA)>
Remarque
<!ELEMENT choix (elt1* | elt2* | elt3*)> est différent de <!ELEMENT choix (elt1 |
elt2 | elt3)*>. La première veut dire qu'on peut avoir chacun des 3 éléments 0 ou
plusieurs fois mais qu'on ne peut pas avoir deux éléments différents en même temps.
La deuxième veut dire qu'on peut avoir n'importe quel élément dans n'importe quel
ordre et autant de fois qu'on le souhaite.
En utilisant cette deuxième forme, on peut créer des éléments à contenu mixte : <!
ELEMENT choix (#PCDATA | element)*>
o Un élément quelconque : C'est un élément qui peut contenir n'importe quoi (vide, des sous-
éléments, du texte,…) (très déconseillé parce qu'il va à l'encontre du principe de la DTD).

<!ELEMENT Nom_Elément ANY >
2. Déclaration des attributs

Un attribut est toujours associé à un élément :
<!ATTLIST Nom_Element Nom_Attribut Type Option>
Type peut prendre :

 CData : Peut contenir n'importe quel caractère qui respecte les contraintes de forme
 NMTOKEN peut contenir des lettres, des chiffres, un point, un tiret, un trait de
soulignement et deux-points
 NMTOKENS peut contenir les caractères autorisés pour les attributs de type
NMTOKEN en plus des espaces blancs. Par espace blanc, on entend un ou plusieurs
espaces, retours chariot, sauts de ligne ou tabulations.
 ID : La valeur d'un attribut de type ID doit être unique par rapport à l'ensemble des
valeurs de tous les attributs de type ID. Elle peut contenir les caractères autorisés
pour le type NMTOKEN et doit commencer par une lettre.
 IDREF : La valeur doit correspondre à celle de l'un des attributs ID présents dans le
document
 IDREFS : La valeur de l'attribut IDREFS peut contenir plusieurs références à des
éléments comportant un attribut ID en les séparant par des espaces blancs.
 (Valeur1, Valeur2,…) : peut prendre une des valeurs fournies dans la liste
Option peut prendre :

 Une valeur par défaut : "Valeur"
 #REQUIRED : Pour indiquer que c'est un attribut obligatoire
 #IMPLIED : Pour indiquer que c'est un attribut optionnel
 #FIXED "Valeur" : Pour indiquer que c'est une valeur fournie qui est fixé
Exemple
<!ATTLIST produit categorie CDATA "Fournitures">
Remarque
Il est possible de déclarer plusieurs attributs d'un seul élément en même temps :
<!ATTLIST elt Attribut1 Type Option Attribut2 Type Option
…>
3. Déclaration des entités

Il existe plusieurs types d'entités :
o Les entités paramétriques : Permettent de définir des noms raccourcis qui pourront être
utilisés pour remplacer des séquences trop longues qui reviennent souvent dans une DTD.
Elles peuvent également être utilisées pour insérer des fragments de DTD provenant d'un
fichier externe mais elles ne peuvent être utilisées qu'à l'intérieur de la DTD :
<!ENTITY % Nom_Entité "Valeur_Représentée">

Pour inclure une partie de DTD provenant d'un document externe :
<!ENTITY % Nom_Entité SYSTEM " URL ">
Pour utiliser une entité paramétrique, il suffit d'indiquer son nom précédé par le symbole %
.
% Nom_Entité ;
Exemple
<!ENTITY % Reference "nom|designation|titre"
<!ELEMENT produit (nom|designation|titre,prix,fournisseur)

Peut être remplacé par :
<!ELEMENT produit (%Reference,prix,fournisseur)
Exemple
<!ENTITY % test SYSTEM "xx.dtd"
Pour l'utiliser :
%test;
o Les autres entités : Ce sont des symboles pouvant être définis dans une DTD et utilisés dans
un document XML comme raccourcis d'écriture ou pour représenter des caractères qui ne
sont pas représentables dans l'alphabet utilisé, qui ne sont pas disponibles au clavier ou qui,
utilisés tel quel, risquent de créer des conflits avec d'autres caractères. La définition complète
du symbole est entièrement incluse dans la DTD.
<!ENTITY Nom_Entité "valeur">
<!ENTITY Nom_Entité "&#xNombreAC;">
<!ENTITY Nom_Entité "Fragment HTML">
<!ENTITY nom SYSTEM "Fichier">
Pour utiliser une entité :

&Nom_Entité;
Remarque
Une entité peut être utilisée à n'importe quel endroit dans le fichier XML même en tant que valeur
d'attribut.
Exemple
<!ENTITY Euro "€">
<!ENTITY MCD "Modèle Conceptuel de Données">
<type>Le symbole &Euro; est spécial</type>

<definition>Le &MCD; est un modèle….</definition>
Remarque

Les cinq caractères '<', '>' , '&', ''' et '"' ont une signification particulière dans les
documents XML. Pour introduire ces caractères dans le contenu du document, il faut utiliser
des entités prédéfinies.
Entité Caractère
< <
> >
& &
' '
" "
Remarque
Ce type d'entités peut être utilisé dans la DTD et dans le fichier XML.
<type>Chaine de &car;</type>
Une entité peut désigner un fragment de document contenu dans un autre fichier :
<!ENTITY Nom_Entité SYSTEM "Fichier.xml">
Exemple
<!ENTITY ch1 SYSTEM "Chapitre1.xml">
<!ENTITY ch2 SYSTEM "Chapitre2.xml">
<livre>
&ch1;
&ch2;
</livre>
II. Les schémas XSD (XML Schema Definition)

Les schémas XSD sont une autre manière de spécifier les règles de validation d'un fichier XML. Ils
présentent l'avantage d'être écrit au format XML (contrairement aux DTD qui sont écrit dans le
langage SGML) et ils apportent un ensemble d'avantages par rapport aux DTD : Les types de
données sont gérés (string, date, booléen,…), les occurrences sont plus précises, l'héritage est
autorisé,…
<?xml version="1.0" encoding="ISO-8859-1"?>

<xsd:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

</xsd:schema>
L'attribut xmlns:xs détermine l'espace de noms par défaut pour le schéma XML. Un espace de noms
détermine d'où sont issues les règles de validation et le vocabulaire. L'espace de noms des schémas
XML est identifié par l'URI "http://www.w3.org/2001/XMLSchema".
Remarque
On peut utiliser le prefixe xsd ou xs.

Un schéma XML se compose essentiellement de déclarations d'éléments (xsd:element),
d'attributs (xsd:attribute) et de définitions de types (xsd:simpleType ou xsd:complexType).
Pour insérer un commentaire dans un schéma :

<xsd:annotation>
<xsd:documentation xml:lang="fr">
Commentaire en français
</xsd:documentation>
<xsd:appInfo>
Information destinée aux applications
</xsd:appInfo>
</xsd:annotation>
Le schéma XSD peut être fourni dans le même fichier XML et peut être externe.
<xsd:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

</xsd:schema>
<Balise_Racine>
…
</ Balise_Racine>
Le schéma XSD peut être fourni dans un fichier .XSD externe. Pour associer un schéma à un fichier
XML :

<balise_Racine xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="Fichier.xsd">
Chaque élément est déclaré avec un type qui peut être, soit un des types prédéfinis, soit un nouveau type
défini dans le schéma. Le type spécifie quels sont les contenus valides de l'élément ainsi que ses attributs.
Un élément est soit de type simple s'il contient des données soit de type complexe s'il contient des attributs
et/ou des sous-éléments (éléments enfants).
1. Déclaration d'éléments simples :

Pour déclarer un élément simple dans un schéma XSD :
<xsd:element name="Nom_Elément" Type="Nom_Type">
</xsd:element>
Ou
<xsd:element name="Nom_Elément" Type="Nom_Type"/>
Avec Nom_Type peut prendre le nom d'un type de base (sous la forme xsd:Type_Donnée) ou le
nom d'un type simple déclaré dans le schéma.
Type_Donnée peut prendre une des valeurs exprimées dans le schéma ci-après tiré de Wikipédia
:

Wikipédia schéma
Exemples :
<xsd:element name="NomPro" Type="xsd:string"/>
<xsd:element name="DateCommande" Type="xsd:date"/>
<xsd:element name="NumPro" Type="xsd:positiveInteger"/>
En plus des types de base, il est possible de créer des types simples qui offrent des conditions
supplémentaires sur les types de base :
o Listes : Les types listes sont des suites de types simples (ou atomiques) :
<xsd:simpleType name="Nom_Type">
<xsd:list itemType="xsd:Type_Donnée" />
</xsd:simpleType>
Exemple
<xsd:simpleType name="Tel">
<xsd:list itemType="xsd:positiveInteger" />
</xsd:simpleType>
…
Pour l’utiliser
<xsd:element name="NumTel" Type="Tel"/>
Instances valides
01 44 27 60 11

Remarque
XML Schema possède trois types de listes intégrés : NMTOKENS, ENTITIES et
IDREFS.
o Unions : Pour faire en sorte qu'un type autorise un mélange entre plusieurs types, il est
possible de le faire à l'aide d'une déclaration d'union.
<xsd:simpleType name="NomTypeSimple">
<xsd:union memberTypes="TypeSimple1 TypeSimple2 …" />
</xsd:simpleType>
Exemple
<xsd:simpleType name="Test">
<xsd:union memberTypes="xsd:positiveInteger xsd:string" />
</xsd:simpleType>
…
Pour l’utiliser
<xsd:element name="MonElement" Type=" Test "/>
Instances valides
<MonElement>18</MonElement>
< MonElement >Pompiers </ MonElement >
Il est également possible d'indiquer des contraintes plus fortes sur les types simples ; ces contraintes
s'appellent des "facettes". Elles permettent par exemple de limiter la longueur de notre numéro de
téléphone à 10 nombres.
o Facette maxExclusive : Pour indiquer une valeur maximale
<xsd:restriction base="Nom-Type">
<xsd:maxExclusive value="Valeur" />
</xsd:restriction>
</xsd:simpleType>
o Facette minExclusive : Pour indiquer une valeur minimale

<xsd:restriction base="Nom-Type">
<xsd:minExclusive value="Valeur" />
</xsd:restriction>
</xsd:simpleType>
o Facette enumeration : Pour énumérer la liste des valeurs possibles

<xsd:simpleType name="NomType">
<xsd:restriction base="Nom_Type">
<xsd:enumeration value="Valeur1" />
<xsd:enumeration value=" Valeur2" />
…
</xsd:restriction>
</xsd:simpleType>
o Facette length : Pour spécifier la longueur d'une chaine

<xsd:simpleType name="NomType">
<xsd:restriction base="Nom_Type">
<xsd:length value="Valeur-Max" />
</xsd:restriction>
</xsd:simpleType>
o Facette pattern : Pour obliger les données à respecter un modèle

<xsd:restriction base="Nom_Type_Base">
<xsd:pattern value="Modèle" /> (une expression régulière que doit
respecter la données pour cet éléments)
</xsd:restriction>
</xsd:simpleType>
2. Déclaration d'attributs :
Pour déclarer un attribut :
<xsd:attribute name="Nom_Attribut" Type="xsd:Type_Données"
use="required|optional|prohibited" default="ValeurParDéfaut"
fixed="Valeur"/>
Les types de données utilisés pour les attributs sont les mêmes types que pour les éléments de
type simple.
3. Déclaration d'éléments complexes :

Les Types complexes peuvent être déclarés de deux manières :
o Première manière (déclaration locale) :
<xsd:element name="Nom_Elément">
<xsd:complexType>

</xsd:complexType>
</xsd:element>
o Deuxième manière (déclaration globale):

<xsd:element name="Nom_Elément" type="NomTypeComplexe"/>
….
<xsd:complexType name="NomTypeComplexe">

</xsd:complexType>
Les éléments complexes peuvent contenir :

o Une séquence d'éléments : une liste de sous-éléments simples ou complexes
<xsd:complexType>
<xsd:sequence>


</xsd:sequence>
</xsd:complexType>
o Une liste de choix : Une liste d'éléments au choix. Un seul élément doit apparaitre
<xsd:complexType>
<xsd:choice>

</xsd:choice>
</xsd:complexType>
o Un élément all : Indique que les éléments enfants doivent apparaître une fois (ou pas du
tout), et dans n'importe quel ordre.
<xsd:complexType>
<xsd:all>

</xsd:all>
</xsd:complexType>
Remarque
Cet élément xsd:all doit être un enfant direct de l'élément xsd:complexType.
o Un élément contenant du texte et des attributs :

<xsd:complexType mixed="true">
<xsd:attribute …. />
…
</xsd:complexType>
</xsd:element>
o Un élément contenant des données d'un certain type et des attributs :

<xsd:complexType>
<xsd:simpleContent>
<xsd:extension base="xsd:Type">
…
</xsd:extension>
</xsd:simpleContent>
</xsd:complexType>
4. Configuration du nombre d'occurrences

Par défaut, les éléments déclarés apparaissent une et une seule fois. Pour modifier ce
comportement on utilise les attributs minOccurs et MaxOccurs :
o Minoccurs : Indique le minimum de fois que doit apparaitre l'élément. Elle prend n'importe
quel nombre supérieur ou égal à 0 et inférieur ou égal à maxOccurs.
o Maxoccurs : Indique le maximum de fois que doit apparaitre l'élément. Ce nombre doit être
strictement positif ou prend la valeur "unbounded" pour indiquer qu'il n'y a pas de limite.
<xsd:element name="…" minoccurs="Valeur" maxoccurs="valeur"…
Remarque :
Pour indiquer qu’un élémet XML est non renseigné (null) on utilise xsi:null au niveau de
l’élément dans le fichier XML.
<Element attribut1="…" attribut2="…" ….. xsi:null></Element>
Remarque
Il est possible de scinder un schémas XSD trop long en plusieurs parties. Pour inclure un schéma
:
<xsd:include schemaLocation="Chemin.xsd" />
Exemple :
Soit la DTD suivante :
<?xml version="1.0" encoding="UTF-8"?>

<!ELEMENT LesCours (cours*)>
<!ELEMENT cours (titre,auteur?,exercices?,reference*)>
<!ELEMENT titre (#PCDATA)>
<!ELEMENT auteur (#PCDATA)>
<!ELEMENT reference (numArticle|nomLivre)>
<!ELEMENT exercices (exercice+)>
<!ELEMENT numArticle (#PCDATA)>
<!ELEMENT nomLivre (#PCDATA)>
<!ELEMENT exercice (#PCDATA)>
<!ATTLIST cours type (Théorique|Pratique) "Théorique">
<!ATTLIST exercice categorie CDATA "TD">
Un exemple de fichier XML correspondant :

<!DOCTYPE LesCours SYSTEM "Madtd.dtd">
<LesCours>
<cours type="Pratique">
<titre>DTD</titre>
<auteur>Aut1</auteur>
<exercices>
<exercice categorie="Devoir">Dev1</exercice>

<exercice>Exe1</exercice>
</exercices>
</cours>
<titre>XML</titre>
<reference>
<numArticle>1</numArticle>
</reference>
<reference>
<nomLivre>liv1</nomLivre>
</reference>
</cours>
<titre>XSLT</titre>
<auteur>Aut2</auteur>
<exercices>
<exercice>exe2</exercice>
<exercice>exe3</exercice>
</exercices>
<reference>
<numArticle>2</numArticle >
</reference>
</cours>
</LesCours>
Le schéma XSD correspondant est :
Méthode 1 :


<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified"
attributeFormDefault="unqualified">
<xs:element name="LesCours">
<xs:complexType>
<xs:sequence>
<xs:element name="cours" minOccurs="0" maxOccurs="unbounded">
<xs:complexType>
<xs:sequence>
<xs:element name="titre" type="xs:string"/>
<xs:element name="auteur" type="xs:string" minOccurs="0"/>
<xs:element name="exercices" minOccurs="0">
<xs:complexType>
<xs:sequence>
<xs:element name="exercice" minOccurs="0" maxOccurs="unbounded">
<xs:complexType mixed="true">
<xs:attribute name="categorie" type="xs:string" use="optional"
default="TD"/>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>

</xs:element>
<xs:element name="reference" minOccurs="0" maxOccurs="unbounded">
<xs:complexType>
<xs:choice>
<xs:element name="numArticle" type="xs:string"/>
<xs:element name="nomLivre" type="xs:string"/>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:sequence>
<xs:attribute name="type" type="ListeTypes" use="optional" default="Théorique"/>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:simpleType name="ListeTypes">
<xs:restriction base="xs:string">
<xs:enumeration value="Théorique"/>
<xs:enumeration value="Pratique"/>
<xs:enumeration value=" Autre"/>
</xs:restriction>
</xs:simpleType>
</xs:schema>
Méthode 2


<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified"
attributeFormDefault="unqualified">
<xs:element name="LesCours" type="TLesCours"/>
<xs:simpleType name="ListeTypes">
<xs:restriction base="xs:string">
<xs:enumeration value="Théorique"/>
<xs:enumeration value="Pratique"/>
<xs:enumeration value=" Autre"/>
</xs:restriction>
</xs:simpleType>
<xs:complexType name="TLesCours">
<xs:sequence>
<xs:element name="cours" type="TCours" minOccurs="0"
maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="TCours">
<xs:sequence>
<xs:element name="titre" type="xs:string"/>
<xs:element name="auteur" type="xs:string" minOccurs="0"/>

<xs:element name="exercices" type="TExercices" minOccurs="0"/>
<xs:element name="reference" type="TReference" minOccurs="0"
</xs:sequence>
<xs:attribute name="type" type="ListeTypes" use="optional" default="Théorique"/>
</xs:complexType>
<xs:complexType name="TReference">
<xs:choice>
<xs:element name="numArticle" type="xs:string"/>
<xs:element name="nomLivre" type="xs:string"/>
</xs:choice>
</xs:complexType>
<xs:complexType name="Texercice" mixed="true">
<xs:attribute name="categorie" type="xs:string" use="optional" default="TD"/>
</xs:complexType>
<xs:complexType name="TExercices">
<xs:sequence>
<xs:element name="exercice" type="Texercice" minOccurs="0"
</xs:sequence>
</xs:complexType>
</xs:schema>

Ok DTD XSD

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Ok DTD XSD

Transféré par

Droits d'auteur :

Formats disponibles

VALIDATION D’UN FICHIER XML

Naoual ABDALLAH / DTD-XSD 1

Naoual ABDALLAH / DTD-XSD 2

I. Les DTD (Document Type Definition)

o Déclaration d'une DTD externe locale

o Déclaration d'une DTD externe publique

Type_Element peut être :

Exemple d'élément de type texte :

Occ peut prendre :

Naoual ABDALLAH / DTD-XSD 3

Exemples d'éléments contenant des séquences d'éléments :

<!ELEMENT produit (nom,prix,fournisseur+)>

Exemples d'éléments vides :

<!ELEMENT transport EMPTY>

Naoual ABDALLAH / DTD-XSD 4

Exemples d'éléments contenant des séquences d'éléments avec des choix :

Naoual ABDALLAH / DTD-XSD 5

2. Déclaration des attributs

Type peut prendre :

Option peut prendre :

3. Déclaration des entités

Naoual ABDALLAH / DTD-XSD 6

<!ELEMENT produit (nom|designation|titre,prix,fournisseur)

Pour utiliser une entité :

<type>Le symbole &Euro; est spécial</type>

Naoual ABDALLAH / DTD-XSD 7

II. Les schémas XSD (XML Schema Definition)

<?xml version="1.0" encoding="ISO-8859-1"?>

Naoual ABDALLAH / DTD-XSD 8

Pour insérer un commentaire dans un schéma :

<?xml version="1.0" encoding="ISO-8859-1"?>

1. Déclaration d'éléments simples :

Naoual ABDALLAH / DTD-XSD 9

Naoual ABDALLAH / DTD-XSD 10

o Facette minExclusive : Pour indiquer une valeur minimale

o Facette enumeration : Pour énumérer la liste des valeurs possibles

o Facette length : Pour spécifier la longueur d'une chaine

Naoual ABDALLAH / DTD-XSD 11

o Facette pattern : Pour obliger les données à respecter un modèle

3. Déclaration d'éléments complexes :

o Deuxième manière (déclaration globale):

Les éléments complexes peuvent contenir :

Naoual ABDALLAH / DTD-XSD 12

o Un élément contenant du texte et des attributs :

o Un élément contenant des données d'un certain type et des attributs :

4. Configuration du nombre d'occurrences

<xsd:element name="…" minoccurs="Valeur" maxoccurs="valeur"…

<Element attribut1="…" attribut2="…" ….. xsi:null></Element>

<?xml version="1.0" encoding="UTF-8"?>

Un exemple de fichier XML correspondant :

<?xml version="1.0" encoding="UTF-8"?>

Naoual ABDALLAH / DTD-XSD 14

Le schéma XSD correspondant est :

<?xml version="1.0" encoding="UTF-8"?>

Naoual ABDALLAH / DTD-XSD 15

<?xml version="1.0" encoding="UTF-8"?>

Naoual ABDALLAH / DTD-XSD 16

Naoual ABDALLAH / DTD-XSD 17

Vous aimerez peut-être aussi