J'ai googlé cette question, mais je ne comprends pas clairement ce qu'est un schéma XML et une DTD (définition de type de document), et pourquoi le schéma XML est plus puissant que DTD.

Toute orientation serait très appréciée.

À partir de la section Différences entre les DTD et le schéma de l' article Conversion d'une DTD en schéma :

La différence critique entre les DTD et le schéma XML est que le schéma XML utilise une syntaxe basée sur XML, tandis que les DTD ont une syntaxe unique conservée par les DTD SGML. Bien que les DTD soient souvent critiqués à cause de ce besoin d'apprendre une nouvelle syntaxe, la syntaxe elle-même est assez laconique. L'inverse est vrai pour XML Schema, qui sont verbeux, mais utilisent également des balises et XML afin que les auteurs de XML trouvent la syntaxe de XML Schema moins intimidante.

Le but des DTD était de conserver un niveau de compatibilité avec SGML pour les applications qui pourraient souhaiter convertir des DTD SGML en DTD XML. Cependant, conformément à l'un des objectifs de XML, «la lacune dans le balisage XML est d'une importance minime», il n'y a pas vraiment de souci de garder la syntaxe brève.

[...]

Alors, quelles sont certaines des autres différences qui pourraient être particulièrement importantes lorsque nous convertissons une DTD? Nous allons jeter un coup d'oeil.

Dactylographie

La différence la plus significative entre les DTD et XML Schema est la capacité de créer et d'utiliser des types de données dans Schema en conjonction avec des déclarations d'éléments et d'attributs. En fait, c'est une différence si importante que la moitié de la recommandation sur le schéma XML est consacrée au typage de données et au schéma XML. Nous couvrons les types de données en détail dans la partie III de ce livre, «XML Schema Datatypes».

[...]

Contraintes d'occurrence

Un autre domaine dans lequel les DTD et le schéma diffèrent considérablement est celui des contraintes d'occurrence. Si vous vous souvenez de nos exemples précédents du chapitre 2, "Structure du schéma" (ou de votre propre travail avec les DTD), il existe trois symboles que vous pouvez utiliser pour limiter le nombre d'occurrences d'un élément: *, + et?.

[...]

Énumérations

Donc, disons que nous avions un élément, et que nous voulions pouvoir définir un attribut de taille pour la chemise, ce qui permettait aux utilisateurs de choisir une taille: petite, moyenne ou grande. Notre DTD ressemblerait à ceci:

<!ELEMENT item (shirt)>
<!ELEMENT shirt (#PCDATA)>
<!ATTLIST shirt
    size_value (small | medium | large)>

[...]

Mais que se passerait-il si nous voulions sizeêtre un élément? Nous ne pouvons pas faire cela avec une DTD. Les DTD ne fournissent pas d'énumérations dans le contenu textuel d'un élément. Cependant, à cause des types de données avec Schema, lorsque nous avons déclaré l'énumération dans l'exemple précédent, nous avons en fait créé un simpleTypeappelé size_valuesque nous pouvons maintenant utiliser avec un élément:

<xs:element name="size" type="size_value">

[...]

Les différences entre une définition de schéma XML (XSD) et une définition de type de document (DTD) incluent:

• Les schémas XML sont écrits en XML tandis que les DTD sont dérivés de la syntaxe SGML.
• Les schémas XML définissent les types de données pour les éléments et les attributs tandis que DTD ne prend pas en charge les types de données.
• Les schémas XML autorisent la prise en charge des espaces de noms, contrairement à DTD.
• Les schémas XML définissent le nombre et l'ordre des éléments enfants, contrairement à DTD.
• Les schémas XML peuvent être manipulés par vous-même avec XML DOM mais ce n'est pas possible en cas de DTD.
• utilisant un schéma XML, l'utilisateur n'a pas besoin d'apprendre une nouvelle langue, mais travailler avec DTD est difficile pour un utilisateur.
• Le schéma XML fournit une communication de données sécurisée, c'est-à-dire que l'expéditeur peut décrire les données d'une manière que le destinataire comprendra, mais en cas de DTD, les données peuvent être mal comprises par le destinataire.
• Les schémas XML sont extensibles tandis que DTD ne l'est pas.

MISE À JOUR : 26/08/2015

Toutes ces puces ne sont pas exactes à 100%, mais vous comprenez l'essentiel.

D'autre part:

• DTD vous permet de définir de nouvelles valeurs ENTITY à utiliser dans votre fichier XML.
• DTD vous permet de l'étendre localement à un fichier XML individuel.

Comme de nombreuses personnes l'ont déjà mentionné, le schéma XML utilise une syntaxe basée sur XML et les DTD ont une syntaxe unique. DTD ne prend pas en charge les types de données, ce qui est important.

Voyons un exemple très simple dans lequel l'université a plusieurs étudiants et chaque étudiant a deux éléments "nom" et "année". Veuillez noter que j'ai des utilisations "// ->" dans mon code juste pour les commentaires.

Maintenant, j'écrirai cet exemple à la fois en DTD et en XSD.

DTD

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE university[              // --> university as root element 
<!ELEMENT university (student*)>   // --> university has  * = Multiple students
<!ELEMENT student (name,year)>     // --> Student has elements name and year
<!ELEMENT name (#PCDATA)>          // --> name as Parsed character data
<!ELEMENT year (#PCDATA)>          // --> year as Parsed character data
]>

<university>
    <student>
        <name>
            John Niel             //---> I can also use an Integer,not good
        </name>
        <year>
            2000                 //---> I can also use a string,not good
        </year>
    </student>
</university>

Définition de schéma XML (XSD)

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

<xsd:complexType name ="uniType">                    //--> complex datatype uniType
 <xsd:sequence>
  <xsd:element ref="student" maxOccurs="unbounded"/> //--> has unbounded no.of students
 </xsd:sequence>
</xsd:complexType>

<xsd:complexType name="stuType">                     //--> complex datatype stuType
 <xsd:sequence>
  <xsd:element ref="name"/>                          //--> has element name
  <xsd:element ref="year"/>                          //--> has element year
 </xsd:sequence>
</xsd:complexType>

<xsd:element name="university" type="uniType"/>       //--> university of type UniType 
<xsd:element name="student" type="stuType"/>          //--> student of type stuType
<xsd:element name="name" type="xsd:string"/>          //--> name of datatype string
<xsd:element name="year" type="xsd:integer"/>         //--> year of datatype integer
</xsd:schema>



<?xml version="1.0" encoding="UTF-8"?>
<university>
    <student>
        <name>
            John Niel          
        </name>
        <year>
            2000                      //--> only an Integer value is allowed
        </year>
    </student>
</university>

La DTD est antérieure au XML et n'est donc pas un XML valide lui-même. C'est probablement la principale raison de l'invention de XSD.

Similitudes entre XSD et DTD

both specify elements, attributes, nesting, ordering, #occurences

Différences entre XSD et DTD

XSD also has data types, (typed) pointers, namespaces, keys and more.... unlike DTD 

De plus, bien que XSD soit peu verbeux, sa syntaxe est une extension de XML, ce qui facilite l'apprentissage rapide.

Une différence est que dans une DTD, le modèle de contenu d'un élément est complètement déterminé par son nom, indépendamment de l'endroit où il apparaît dans le document:

En supposant que vous vouliez avoir

• un personélément
• avec un élément enfant appelé name
• an namelui-même a des éléments enfants firstet last.

Comme ça

   <person>
       <name>
            <first></first>
            <last></last>
       </name>
   </person>

Si un cityélément dans le même document doit également avoir un « nom » élément enfant la DTD exige que cet élément « name » doit avoir des éléments enfants firstet lastaussi bien. Malgré le fait que city.namecela ne nécessite pas firstet lastque les enfants.

En revanche, XML Schema vous permet de déclarer les types d'élément enfant localement; vous pouvez déclarer les nameéléments enfants pour les deux personet cityséparément. En leur donnant ainsi leurs propres modèles de contenu dans ces contextes.

L'autre différence majeure est la prise en charge des espaces de noms. Étant donné que les DTD font partie de la spécification XML d'origine (et héritées de SGML), elles ne sont pas du tout sensibles aux espaces de noms car les espaces de noms XML ont été spécifiés ultérieurement. Vous pouvez utiliser des DTD en combinaison avec des espaces de noms, mais cela nécessite quelques contorsions, comme être forcé de définir les préfixes dans la DTD et d'utiliser uniquement ces préfixes, au lieu de pouvoir utiliser des préfixes arbitraires.

Pour moi, les autres différences sont pour la plupart superficielles. La prise en charge des types de données pourrait facilement être ajoutée aux DTD, et la syntaxe n'est que de la syntaxe. (Pour ma part, je trouve la syntaxe du schéma XML horrible et je ne voudrais jamais gérer manuellement un schéma XML, ce que je ne dirais pas à propos des DTD ou des schémas RELAX NG; si j'ai besoin d'un schéma XML pour une raison quelconque, j'écris généralement un RELAX NG et convertissez-le avec trang.)

Similitudes :

Les DTD et les schémas exécutent tous les deux les mêmes fonctions de base:

• Tout d'abord, ils déclarent tous les deux une longue liste d'éléments et d'attributs.
• Deuxièmement, les deux décrivent comment ces éléments sont regroupés, imbriqués ou utilisés dans le XML. En d'autres termes, ils déclarent les règles selon lesquelles vous autorisez quelqu'un à créer un fichier XML dans votre flux de travail, et
• Troisièmement, les DTD et les schémas fournissent des méthodes pour restreindre ou forcer le type ou le format d'un élément. Par exemple, dans la DTD ou le schéma, vous pouvez forcer un champ de date à être écrit comme 01/05/06 ou 1/5/2006.

Différences:

• Les DTD conviennent mieux aux applications gourmandes en texte, tandis que les schémas présentent plusieurs avantages pour les workflows gourmands en données.

• Les schémas sont écrits en XML et suivent donc les mêmes règles, tandis que les DTD sont écrits dans un langage complètement différent.

Exemples:

DTD:

<?xml version="1.0" encoding="UTF-8"?>
    <!ELEMENT employees (Efirstname, Elastname, Etitle, Ephone, Eemail)>
         <!ELEMENT Efirstname (#PCDATA)>
         <!ELEMENT Elastname (#PCDATA)>
         <!ELEMENT Etitle (#PCDATA)>
         <!ELEMENT Ephone (#PCDATA)>
         <!ELEMENT Eemail (#PCDATA)>

XSD:

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:od="urn:schemas-microsoft-com:officedata">
<xsd:element name="dataroot">
     <xsd:complexType>
          <xsd:sequence>
               <xsd:element ref="employees" minOccurs="0" maxOccurs="unbounded"/>
          </xsd:sequence>
          <xsd:attribute name="generated" type="xsd:dateTime"/>
      </xsd:complexType>
</xsd:element>
<xsd:element name="employees">
      <xsd:annotation>
           <xsd:appinfo>
               <od:index index-name="PrimaryKey" index-key="Employeeid " primary="yes"
                unique="yes" clustered="no"/>
          <od:index index-name="Employeeid" index-key="Employeeid " primary="no" unique="no"
           clustered="no"/>
     </xsd:appinfo>
</xsd:annotation>
     <xsd:complexType>
          <xsd:sequence>
               <xsd:element name="Elastname" minOccurs="0" od:jetType="text"
                od:sqlSType="nvarchar">
                    <xsd:simpleType>
                         <xsd:restriction base="xsd:string">
                              <xsd:maxLength value="50"/>
                         </xsd:restriction>
                    </xsd:simpleType>
               </xsd:element>
               <xsd:element name="Etitle" minOccurs="0" od:jetType="text" od:sqlSType="nvarchar">
                    <xsd:simpleType>
                         <xsd:restriction base="xsd:string">
                              <xsd:maxLength value="50"/>
                         </xsd:restriction>
                    </xsd:simpleType>
               </xsd:element>
               <xsd:element name="Ephone" minOccurs="0" od:jetType="text"
                od:sqlSType="nvarchar">
                    <xsd:simpleType>
                         <xsd:restriction base="xsd:string">
                              <xsd:maxLength value="50"/>
                         </xsd:restriction>
                    </xsd:simpleType>
               </xsd:element>
               <xsd:element name="Eemail" minOccurs="0" od:jetType="text"
               od:sqlSType="nvarchar">
                    <xsd:simpleType>
                         <xsd:restriction base="xsd:string">
                              <xsd:maxLength value="50"/>
                         </xsd:restriction>
                    </xsd:simpleType>
               </xsd:element>
               <xsd:element name="Ephoto" minOccurs="0" od:jetType="text"
                od:sqlSType="nvarchar">
                    <xsd:simpleType>
                         <xsd:restriction base="xsd:string">
                              <xsd:maxLength value="50"/>
                         </xsd:restriction>
                    </xsd:simpleType>
               </xsd:element>
          </xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>

La DTD ne peut avoir que deux types de données, le CDATA et le PCDATA. Mais dans un schéma, vous pouvez utiliser tous les types de données primitifs que vous utilisez dans le langage de programmation et vous avez la possibilité de définir vos propres types de données personnalisés.

Le développeur qui crée un schéma peut créer des types de données personnalisés en fonction des types de données principaux et en utilisant différents opérateurs et modificateurs.

Lorsque XML est sorti pour la première fois, on nous a dit que cela résoudrait tous nos problèmes: XML sera convivial, infiniment extensible, évitera le typage fort et ne nécessitera aucune compétence en programmation. J'ai découvert les DTD et j'ai écrit mon propre analyseur XML. 15+ ans plus tard, je vois que la plupart des XML ne sont pas conviviaux et peu extensibles (selon son utilisation). Dès que certains sabots intelligents ont connecté XML à une base de données, j'ai su que les types de données étaient presque inévitables. Et, vous devriez voir le XSLT (fichier de transformation) que j'ai dû travailler l'autre jour. Si ce n'est pas de la programmation, je ne sais pas ce que c'est! De nos jours, il n'est pas rare de voir toutes sortes de problèmes liés aux données XML ou aux interfaces mal tourner. J'adore XML, mais il s'est éloigné de son point de départ altruiste original.

La réponse courte? Les DTD ont été désapprouvés au profit des XSD car un XSD vous permet de définir une structure XML avec plus de précision.

XML DTD

Le but d'une DTD est de définir la structure d'un document XML. Il définit la structure avec une liste d'éléments juridiques:

<!ATTLIST contact type CDATA #IMPLIED>
<!ELEMENT address1 ( #PCDATA)>
<!ELEMENT city ( #PCDATA)>
<!ELEMENT state ( #PCDATA)>
<!ELEMENT zip ( #PCDATA)>

Schéma XML

XML Schema permet aux auteurs de schémas de spécifier que les données de la quantité d'éléments doivent être numériques ou, plus spécifiquement, un entier. Dans l'exemple suivant, j'ai utilisé string:

<xs:element name="note">
<xs:complexType>
  <xs:sequence>
    <xs:element name="address1" type="xs:string"/>
    <xs:element name="city" type="xs:string"/>
    <xs:element name="state" type="xs:string"/>
    <xs:element name="zip" type="xs:string"/>
  </xs:sequence>
</xs:complexType>

La DTD est à peu près obsolète car elle est limitée dans son utilité en tant que langage de schéma, ne prend pas en charge l'espace de noms et ne prend pas en charge le type de données. De plus, la syntaxe de DTD est assez compliquée, ce qui la rend difficile à comprendre et à maintenir.

DTD indique la syntaxe de l'élément XML

Les schémas XML sont l'alternative de Microsoft à DTD pour valider XML