Quelle est la différence entre XML Schema et DTD?
J'ai cherché sur Google cette question, mais je ne comprends pas bien 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 celui de DTD.
Toute orientation serait très appréciée.
De la section Différences entre les DTD et le schéma de la Conversion d'une DTD en schéma de l'article:
La différence critique entre les DTD et le schéma XML réside dans le fait que XML Schema utilise une syntaxe basée sur XML, alors que les DTD ont une syntaxe unique conservée par les DTD SGML. Bien que les DTD soient souvent critiquées à cause de la nécessité d’apprendre une nouvelle syntaxe, la syntaxe elle-même est plutôt concise. Le contraire est vrai pour XML Schema, qui est détaillé, mais utilise également des balises et XML afin que les auteurs de XML puissent trouver la syntaxe de XML Schema moins intimidante.
L'objectif des DTD était de conserver un niveau de compatibilité avec SGML pour les applications susceptibles de convertir des DTD SGML en DTD XML. Cependant, conformément à l’un des objectifs du XML, "la cohérence entre les balises XML est d’une importance minime", il n’est pas vraiment préoccupant de garder la syntaxe brève.
[...]
Alors, quelles sont les 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 le schéma XML réside dans la possibilité de créer et d'utiliser des types de données dans Schema en conjonction avec des déclarations d'élément et d'attribut. En fait, la différence est tellement importante que la moitié de la recommandation de 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 troisième partie de ce livre, "XML Schema Datatypes".
[...]
Contraintes d'occurrence
Un autre domaine dans lequel les DTD et les schémas diffèrent considérablement est celui des contraintes d’occurrence. Si vous vous rappelez de nos exemples précédents au chapitre 2, "Structure du schéma" (ou de votre propre travail avec les DTD), vous pouvez utiliser trois symboles pour limiter le nombre d'occurrences d'un élément: *, + et?.
[...]
Énumérations
Supposons donc que nous ayons 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 si nous voulions que
sizesoit un élément? Nous ne pouvons pas faire cela avec une DTD. Les DTD ne prévoient pas d'énumération 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éé unesimpleTypeappeléesize_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) sont les suivantes:
- 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 permettent 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 à la 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.
- utiliser 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. L’expéditeur peut décrire les données d’une manière que le destinataire comprendra, mais dans le cas d’une DTD, les données peuvent être mal comprises par le destinataire.
- Les schémas XML sont extensibles alors que DTD n'est pas extensible.
UPDATE: 2015.08.26
Tous ces points ne sont pas précis à 100%, mais vous obtenez le Gist.
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 beaucoup de gens l'ont déjà mentionné, XML Schema utilise une syntaxe basée sur XML et les DTD ont une syntaxe unique. DTD ne supporte pas les types de données, ce qui est important.
Voyons un exemple très simple dans lequel une université a plusieurs étudiants et chaque étudiant a deux éléments "nom" et "année". S'il vous plaît noter que j'ai utilise "// ->" dans mon code juste pour les commentaires.
Maintenant, je vais écrire cet exemple à la fois dans DTD et dans 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>
DTD est antérieure à XML et n'est donc pas valide en tant que telle. C'est probablement la principale raison de l'invention de XSD.
Similarités 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 détaillé, sa syntaxe est une extension de XML, ce qui facilite l'apprentissage rapide.
Une différence réside également dans le fait que dans une DTD, le modèle de contenu d'un élément est entièrement déterminé par son nom, indépendamment de l'endroit où il apparaît dans le document. Supposons donc que vous souhaitiez avoir un élément enfant name de votre élément person qui comporte lui-même des éléments enfants first et last. Ensuite, si vous souhaitez avoir un élément enfant name pour un élément city dans le même document, vous devez également disposer d'éléments enfants first et last. En revanche, XML Schema vous permet de déclarer localement les types d'élément enfant, vous pouvez donc déclarer les éléments enfant name pour person et city séparément, en leur donnant le modèle de contenu approprié. dans ces contextes.
L'autre différence majeure est le support 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 conscientes des 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 certaines contorsions, par exemple être forcé de définir les préfixes dans la DTD et de n'utiliser que ces préfixes, au lieu de pouvoir utiliser des préfixes arbitraires.
Pour moi, les autres différences sont surtout superficielles. La prise en charge des types de données pourrait facilement être ajoutée aux DTD, et la syntaxe n’est que syntaxe. (Pour ma part, j’ai trouvé la syntaxe du schéma XML horrible et je ne voudrais jamais maintenir à la main 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 Pour une raison quelconque, j’écris habituellement un RELAX NG et le convertit avec trang.)
similitudes:
Les DTD et les schémas remplissent les mêmes fonctions de base:
- Premièrement, ils déclarent tous deux une liste exhaustive 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 permettant de restreindre ou de forcer le type ou le format d'un élément. Par exemple, dans la DTD ou le schéma, vous pouvez forcer l'écriture d'un champ de date sous la forme 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 flux de travail intensifs en données.
Les schémas sont écrits en XML et suivent donc les mêmes règles, tandis que les DTD sont écrites 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 construit 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 apparu 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 connaissance en programmation. J'ai entendu parler de DTD et écrit mon propre analyseur XML. Quinze ans plus tard, je constate que la plupart des fichiers XML ne sont pas conviviaux et peu extensibles (en fonction de leur utilisation). Dès que des sabots intelligents ont relié XML à une base de données, j'ai su que les types de données étaient presque inévitables. Et vous devriez voir le fichier XSLT (fichier de transformation) que je devais 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 se détériorer. J'adore le XML, mais il s'est éloigné de son point de départ altruiste d'origine.
La réponse courte? Les DTD sont déconseillées au profit de XSD car un XSD vous permet de définir une structure XML avec plus de précision.
DTD XML
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éma de spécifier que les données de la quantité d’éléments doivent être numériques ou, plus précisément, entières. 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>
DTD est à peu près obsolète car son utilité en tant que langage de schéma est limitée, il ne prend pas en charge les espaces de noms et les types de données. De plus, la syntaxe de DTD est assez compliquée, ce qui la rend difficile à comprendre et à maintenir.