Jaka jest różnica między XML Schema a DTD?

Różnice między definicją schematu XML (XSD) a definicją typu dokumentu (DTD) obejmują:

• schematy XML są zapisywane w XML, podczas gdy DTD wywodzą się ze składni SGML.
• schematy XML definiują typy danych dla elementów i atrybutów, podczas gdy DTD nie obsługuje typów danych.
• schematy XML umożliwiają obsługę przestrzeni nazw, podczas gdy DTD nie.
• schematy XML definiują liczbę i kolejność elementów potomnych, podczas gdy DTD nie.
• schematy XML można manipulować na Twoim własne z XML DOM, ale nie jest to możliwe w przypadku DTD.
• using XML schema user need to learn a new language but working with DTD is difficult for a user.
• XML schema zapewnia bezpieczną komunikację danych, tzn. nadawca może opisać dane w sposób, który odbiorca zrozumie, ale w przypadku danych DTD może być źle zrozumiany przez odbiorcę.
• schematy XML są rozszerzalne, podczas gdy DTD nie jest rozszerzalne.

Aktualizacja: 2015.08.26

Nie wszystkie te punktory są w 100% dokładne, ale rozumiesz sedno.

Z drugiej strony:

• DTD pozwala zdefiniować nowe wartości encji do użycia w pliku XML.
• DTD pozwala rozszerzyć go lokalnie na pojedynczy plik XML.

DTD poprzedza XML i dlatego nie jest poprawnym samym XML. To prawdopodobnie największy powód wynalazku XSD.

Jak Wiele osób wspomniało wcześniej, XML Schema wykorzystuje składnię opartą na XML, a DTD ma unikalną składnię. DTD nie obsługuje typów danych, co ma znaczenie.

Zobaczmy bardzo prosty przykład, w którym uniwersytet ma wielu studentów i każdy student ma dwa elementy " nazwa "i"rok". Zauważ, że w kodzie używam "/ / -- > " tylko do komentowania.

Teraz napiszę ten przykład zarówno w DTD jak i w 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>

XML Schema Definition (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>

Podobieństwa między XSD i DTD

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

Różnice między XSD i DTD

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

Co więcej, chociaż XSD jest mało gadatliwy, jego składnia jest rozszerzeniem XML, co ułatwia szybką naukę.

Różnica polega również na tym, że w DTD model zawartości elementu jest całkowicie określony przez jego nazwę, niezależnie od tego, gdzie pojawia się w dokumencie. Powiedzmy więc, że chcesz mieć element potomny name twojego elementu person, który sam zawiera elementy potomne first i last. Następnie, jeśli chcesz mieć element potomny name dla elementu potomnego city w tym samym dokumencie, który również musi mieć elementy potomne first i last. Natomiast XML Schema pozwala zadeklarować element potomny typy lokalnie, więc w tym przypadku Można zadeklarować name elementy potomne dla person i city oddzielnie, podając im odpowiednie modele treści w tych kontekstach.

Inną istotną różnicą jest obsługa przestrzeni nazw. Ponieważ DTD są częścią oryginalnej specyfikacji XML (odziedziczonej po SGML), w ogóle nie są świadome przestrzeni nazw, ponieważ przestrzenie nazw XML zostały określone później. Możesz używać DTD w połączeniu z przestrzeniami nazw, ale wymaga to pewnych kontorów, takich jak bycie zmuszony do zdefiniowania prefiksów w DTD i używania tylko tych prefiksów, zamiast móc używać dowolnych prefiksów.

Podobieństwa :

DTD i schematy wykonują te same podstawowe funkcje:

• Po pierwsze, obie deklarują listę elementów i atrybutów.
• Po Drugie, oba opisują, w jaki sposób te elementy są grupowane, zagnieżdżane lub używane w XML. Innymi słowy, deklarują reguły, według których zezwalasz komuś na tworzenie pliku XML w Twoim obiegu pracy i
• Po trzecie, zarówno DTD, jak i schematy zapewniają metody ograniczania lub wymuszania typu lub format elementu. Na przykład w DTD lub schemacie można wymusić zapisanie pola daty jako 01/05/06 lub 1/5/2006.

Różnice:

• DTD są lepsze dla aplikacji intensywnie tekstowych, natomiast Schematy mają kilka zalet dla przepływów pracy intensywnie danych.

• Schematy są zapisywane w XML i w związku z tym postępują zgodnie z tymi samymi zasadami, podczas gdy DTD są zapisywane w zupełnie innym język.

Przykłady:

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>

DTD może mieć tylko dwa typy danych, CDATA i PCDATA. Ale w schemacie można użyć wszystkich prymitywnych typów danych, które są używane w języku programowania i masz elastyczność definiowania własnych typów danych niestandardowych.

Programista budujący schemat może tworzyć własne typy danych w oparciu o podstawowe typy danych oraz przy użyciu różnych operatorów i modyfikatorów.

XML DTD

Celem DTD jest zdefiniowanie struktury dokumentu XML. Definiuje strukturę z listą elementów prawnych:

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

XML Schema

XML Schema umożliwia autorom schematów określenie, że dane elementu muszą być liczbowe lub, dokładniej, liczba całkowita. W poniższym przykładzie użyłem 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>

Kiedy XML pojawił się po raz pierwszy, powiedziano nam, że rozwiąże wszystkie nasze problemy: XML będzie przyjazny dla użytkownika, nieskończenie rozszerzalny, uniknie silnego pisania i nie będzie wymagał żadnych umiejętności programistycznych. Dowiedziałem się o DTD i napisałem własny parser XML. 15 + lat później, widzę, że większość XML nie jest przyjazny dla użytkownika ,i nie bardzo rozszerzalny (w zależności od jego użycia). Jak tylko jakieś sprytne chodaki podłączyły XML do bazy danych, wiedziałem, że typy danych są nieuniknione. I powinieneś zobaczyć XSLT / align = "left" / Jeśli to nie jest programowanie, to nie wiem, co to jest! W dzisiejszych czasach nie jest niczym niezwykłym, że wszelkiego rodzaju problemy związane z danymi XML lub interfejsami gone bad. Uwielbiam XML, ale odbiegł on od oryginalnego altruistycznego punktu wyjścia.

Krótka odpowiedź? DTD zostały wycofane na rzecz XSD, ponieważ XSD pozwala definiować strukturę XML z większą precyzją.

DTD jest dość przestarzały, ponieważ ma ograniczoną przydatność jako język schematu, nie obsługuje przestrzeni nazw i nie obsługuje typów danych. Ponadto składnia DTD jest dość skomplikowana, co utrudnia jej zrozumienie i utrzymanie..

DTD wskazuje składnię elementu XML

Schematy XML są alternatywą Microsoftu dla DTD do walidacji XML