TechWeb
Accueil Codage HTML CSS DESIGN XML LaboCSS

Schema

Limitations des DTD

Les dtd utilisent leur propre langage

Le langage utilisé pour la définition des DTD n'est pas du XML, en conséquence il peut être nécessaire d'utiliser un outil différent.

La vérification de la correction syntaxique doit se faire manuellement.

Il n'est pas possible typer les données requises dans un fichier XML

Dans une DTD on peut pas préciser des contraintes sur les données textuelles (#PCDATA)

Il peut être souhaitable de pouvoir containdre le texte requis (un nombre entier, une date etc ...)

Avantage des schemas

Les schemas sont décrit en XML

Les fichier XML et les schema peuvent être traités avec les mêmes outils

La vérification syntaxique peut être automatisée. Le schema étant un fichier XML, il est aisé de vérifier si le document est bien formé. On peut même vérifier sa validité par rapport à une DTD ou un schema (méta-schema).

Typage des données

Les shema permettent d'être plus précis quant au type des données requises. On peut ainsi imposer la saisie d'un nombre ou une date par exemple là où une DTD requérait un simple texte libre de toute contrainte (#PCDATA)

Contraintes plus précises

Les schemas permettent de décrire des contraintes plus fines que celles imposées par une DTD à la structure d'un fichier XML

Structure d'un schema XML

Comme un schema est un fichier XML, il débute par le prologue XML :

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

La racine unique d'un schema est : xsd:schema

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

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

    description du schema

</xsd:schema>
    

Tous les éléments utilisés pour la description d'un schema sont prefixés par xsd: qui est une sorte de dictionnaire du vocabulaire propre aux schemas

Bien qu'étant un fichier XML, un schema a toujours pour extension .xsd.

Etablir un lien vers un schema au sein d'un fichier XML

La référence au schema auquel doit se conformer un fichier XML est présent dans la racine du document XML.

<?xml version="1.0" encoding="UTF-8"?>
<élément_racine  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                xsi:noNamespaceSchemaLocation="chemin_vers_fichier.xsd">
</élément_racine>
        

Eléments simples

Un élément simple est un élément sans attribut qui ne peut contenir que du texte

Exemple

fichier xml

<?xml version="1.0" encoding="UTF-8"?>
<valeur xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="simple.xsd">
    bonjour le monde
</valeur>
        

fichier xsd

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

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <xsd:element name="valeur" type="xsd:string"/>
</xsd:schema>
        

L'élément "valeur" est déclaré dans par : <xsd:element name="valeur" type="xsd:string"/>

Dans le cas d'un élément XML simple, la balise xsd:element est une balise vide et comporte deux attributs :

Dans l'exemple ci-dessus le nom de l'élément est "valeur" et son type est : "xsd:string" (une chaine de caractères)

La validation des exemples peut être réalisée via des logiciels spécialisés ou par le bias d'un validateur en ligne tel : utilities-online ou online XML schema validator

Quelques types prédéfinis

Valeur par défaut

On peut attribuer une valeur par défaut à un élément simple qui sera utilisée si aucune autre valeur n'est donnée.

<xsd:element name="valeur" type="xsd:integer" default="0"/>
        

remarque

L'absence d'une valeur dans le code XML impose que le contenu soit complètement vide (ni espace, tabulation ou saut de ligne), ce qui n'est pas le cas dans le code suivant :

<valeur>
</valeur>
        

il faut donc écrire :

<valeur></valeur>
        

Valeur fixée

On peut également fixer la valeur d'un élément simple :

<xsd:element name="valeur" type="xsd:integer" fixed="0"/>
        

Dès lors la valeur de l'élément est imposée

Dans ce cas l'élément XML correspondant ne peut contenir que cette valeur fixée ou être vide

La remarque précédente concernant les éléments vide s'applique

Les attributs

Les éléments dotés d'attributs, ne sont pas considérés comme simples; mais complexes

Syntaxe d'une déclaration d'attribut

<xsd:attribute name="le_nom" type="le_type"/>

Type d'un attribut

Le type d'un attribut sont ceux autorisés pour un élément simple dont :

Exemple

<xsd:attribute name="prix" type="xsd:decimal"/>
<xsd:attribute name="lang" type="xsd:string"/>

Valeur par défaut

On peut affecter une valeur par défaut à un attribut qui sera prise en compte lorsqu'aucune valeur n'est spécifiée.

<xsd:attribute name="lang" type="xsd:string" default="fr"/>

Valeur fixée

On peut affecter une valeur fixe à un attribut. Toute autre valeur sera invalide.

<xsd:attribute name="lang" type="xsd:string" fixed="fr"/>

Attributs obligatoires ou optinels

Par défaut un attribut est optionnel

Il est possible d'imposer la présence d'un attribut le rendant obligatoire

<xsd:attribute name="lang" type="xsd:string" use="required"/>

Restriction sur les type d'éléments ou d'attributs : les facettes

l'utilisateur peut définir ses propres type pour les valeur textuelles ou les valeurs d'attributs

Exemple : valeur bornée

Supposons que l'on souhaite définir un élément simple <moyenne> devant accepter un entier entre 0 et 20

<?xml version="1.0" encoding="UTF-8"?>
<moyenne xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="simple.xsd">
    18
</moyenne>
        

Pour imposer une valeur entière comprise entre 0 et 20 on définit un type qui restreint le type prédéfini : xsd:integer de la manière suivante :

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

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

    <!-- on définit un type "note" en bornant les valeurs acceptables -->
    
    <xsd:simpleType name="note">
        <xsd:restriction base="xsd:integer">
            <xsd:minInclusive value="0"/>
            <xsd:maxInclusive value="20"/>
        </xsd:restriction>
    </xsd:simpleType>
    
    <!-- on déclare l'élément moyenne ayant une valeur du type "note" défini précédemment -->
    
    <xsd:element name="moyenne" type="note"/>
    
</xsd:schema>
        

Une autre façon de procéder consiste à définir la restriction au sein même de l'élément

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

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    
<xsd:element name="moyenne">
  <xsd:simpleType>
    <xsd:restriction base="xsd:integer">
      <xsd:minInclusive value="0"/>
      <xsd:maxInclusive value="20"/>
    </xsd:restriction>
  </xsd:simpleType>
</xsd:element>

</xsd:schema>
        

En utilisant la première méthode, le type restreint est nommé (note) et peut donc être réutilisé à différents endroits, tandis qu'avec la seconde méthode le type ne pourra s'appliquer qu'à l'élément auquel il est intégré.

Restriction à un ensemble de valeurs

Pour imposer une valeur parmi une liste prédéfinie de valeurs :

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

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

    <!-- on définit un type "mention"  -->
    
    <xsd:simpleType name="mention">
        <xsd:restriction base="xsd:string">
            <xsd:enumeration value="Passable"/>
            <xsd:menumeration value="Assez bien"/>
            <xsd:menumeration value="Bien"/>
            <xsd:menumeration value="Très Bien"/>
        </xsd:restriction>
    </xsd:simpleType>
</xsd:schema>
        

Restriction par une expression régulière (pattern)

Une valeur devant se composer uniquement de lettres majuscule

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

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

    <!-- on définit un type "alpha"  -->
    
    <xsd:simpleType name="majuscules">
        <xsd:restriction base="xsd:string">
            <xsd:pattern value="[A-Z]+"/>
        </xsd:restriction>
    </xsd:simpleType>
    
</xsd:schema>
        

Une valeur figurant la situation familiale

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

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

    <!-- on définit un type "situation"  -->
    
    <xsd:simpleType name="situation">
        <xsd:restriction base="xsd:string">
            <xsd:pattern value="(célibataire|marié|divorcé|veuf)"/>
        </xsd:restriction>
    </xsd:simpleType>
    
</xsd:schema>
        

Dans le cas de la situation familiale on aurait également pu utiliser une énumération

Restriction portant sur la longueur

Fixer la longueur

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

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

    <!-- on définit un type "password"  -->
    
    <xsd:simpleType name="password">
        <xsd:restriction base="xsd:string">
            <xsd:length value="10"/>
        </xsd:restriction>
    </xsd:simpleType>
    
</xsd:schema>
        

Borner la longueur

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

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

    <!-- on définit un type "password"  -->
    
    <xsd:simpleType name="password">
        <xsd:restriction base="xsd:string">
            <xsd:minLength value="8"/>
            <xsd:maxLength value="12"/>
        </xsd:restriction>
    </xsd:simpleType>
    
</xsd:schema>
        

Liste des restrictions :

Les éléments complexes

Rappelons que les éléments dits simples sont des éléments sans attribut qui ne contiennent que du texte

En conséquence tout autre élément est complexe si :

Séquence d'éléments

Pour déclarer un élément "personne" composé d'un élément nom et d'un élément prénom, on utilise la déclaration suivante :

<xsd:element name="personnne">
  <xsd:complexType>
    <xsd:sequence>
      <xsd:element name="prenom" type="xsd:string"/>
      <xsd:element name="nom" type="xsd:string"/>
    </xsd:sequence>
  </xsd:complexType>
</xsd:element> 
        

Une autre solution consiste à nommer ce type d'élément :

<xsd:element name="personnne" type="type_personne">

  <xsd:complexType name="type_persone">
    <xsd:sequence>
      <xsd:element name="prenom" type="xsd:string"/>
      <xsd:element name="nom" type="xsd:string"/>
    </xsd:sequence>
  </xsd:complexType>
        

En procédant de la sorte il est possible de réutiliser le type "type_personne"

<xsd:element name="homme" type="type_personne">
<xsd:element name="femme" type="type_personne">

  <xsd:complexType name="type_personne">
    <xsd:sequence>
      <xsd:element name="prenom" type="xsd:string"/>
      <xsd:element name="nom" type="xsd:string"/>
    </xsd:sequence>
  </xsd:complexType>
        

Extension d'un type complexe

Il est possible de définir un type complexe en se basant sur un type complexe déjà existant :

<xsd:element name="personne" type="type_personne_adresse">

  <xsd:complexType name="type_personne">
    <xsd:sequence>
      <xsd:element name="prenom" type="xsd:string"/>
      <xsd:element name="nom" type="xsd:string"/>
    </xsd:sequence>
  </xsd:complexType>
  
  <xsd:complexType name="type_personne_adresse">
    <xs:complexContent>
        <xs:extension base="personne">
            <xs:sequence>
                <xs:element name="ville" type="xs:string"/>
                <xs:element name="pays" type="xs:string"/>
            </xs:sequence>
        </xs:extension>
    </xs:complexContent>
  </xsd:complexType>
        

Eléments au choix

Pour ajouter un élément "telephone" pouvant être un numero portable ou fixe, on utilise la déclaration suivante :

<xsd:element name="personnne">
  <xsd:complexType>
    <xsd:sequence>
      <xsd:element name="prenom" type="xsd:string"/>
      <xsd:element name="nom" type="xsd:string"/>
      <xsd:choice>
            <xsd:element name="portable" type="xsd:string/>
            <xsd:element name="fixe" type="xsd:string/>
      </xsd:choice>
    </xsd:sequence>
  </xsd:complexType>
</xsd:element> 
        
Valid XHTML 1.0 Strict Valid CSS!

Copyright Gabriel Braun 2007