Przeszukałem to pytanie w Google, ale nie rozumiem dokładnie, co to jest schemat XML i DTD (definicja typu dokumentu) i dlaczego schemat XML jest mocniejszy w porównaniu z DTD.

Wszelkie wskazówki byłyby bardzo mile widziane.

Z sekcji Różnice między DTD a schematem artykułu o konwersji DTD na schemat :

Krytyczna różnica między DTD a schematem XML polega na tym, że schemat XML wykorzystuje składnię opartą na języku XML, podczas gdy DTD ma unikalną składnię, która została zastąpiona przez DTD SGML. Chociaż DTD są często krytykowane z powodu konieczności nauczenia się nowej składni, sama składnia jest dość zwięzła. Odwrotnie jest w przypadku schematu XML, który jest rozwlekły, ale także wykorzystuje znaczniki i XML, aby autorzy XML mogli uznać składnię schematu XML za mniej onieśmielającą.

Celem DTD było utrzymanie poziomu kompatybilności z SGML dla aplikacji, które mogą chcieć przekonwertować SGML DTD na XML DTD. Jednak zgodnie z jednym z celów XML, „zwięzłość w znacznikach XML ma minimalne znaczenie”, nie ma żadnego problemu z utrzymaniem zwięzłej składni.

[…]

Więc jakie są inne różnice, które mogą być szczególnie ważne podczas konwertowania DTD? Spójrzmy.

Pisanie na maszynie

Najbardziej znaczącą różnicą między DTD a schematem XML jest możliwość tworzenia i używania typów danych w schemacie w połączeniu z deklaracjami elementów i atrybutów. W rzeczywistości jest to tak ważna różnica, że ​​połowa rekomendacji schematu XML jest poświęcona przetwarzaniu danych i schemacie XML. Szczegółowy opis typów danych znajduje się w części III tej książki, „Typy danych schematu XML”.

[…]

Ograniczenia występowania

Innym obszarem, w którym DTD i schemat znacznie się różnią, są ograniczenia dotyczące występowania. Jeśli pamiętasz z naszych poprzednich przykładów w rozdziale 2, „Struktura schematu” (lub własnej pracy z DTD), istnieją trzy symbole, których możesz użyć do ograniczenia liczby wystąpień elementu: *, + i?.

[…]

Wyliczenia

Załóżmy więc, że mamy element i chcieliśmy mieć możliwość zdefiniowania atrybutu rozmiaru koszuli, który umożliwiał użytkownikom wybór rozmiaru: mały, średni lub duży. Nasze DTD wyglądałoby tak:

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

[…]

A co sizeby było, gdybyśmy chcieli być żywiołem? Nie możemy tego zrobić z DTD. DTD nie zapewniają wyliczeń w treści tekstowej elementu. Jednak ze względu na typy danych ze schematem, kiedy zadeklarowaliśmy wyliczenie w poprzednim przykładzie, w rzeczywistości utworzyliśmy simpleTypecall, size_valuesktórego możemy teraz użyć z elementem:

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

[…]

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

• Schematy XML są zapisywane w XML, podczas gdy DTD wywodzi 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.
• Schematami XML można samodzielnie manipulować za pomocą XML DOM, ale nie jest to możliwe w przypadku DTD.
• Używając schematu XML, użytkownik nie musi uczyć się nowego języka, ale praca z DTD jest trudna dla użytkownika.
• Schemat XML zapewnia bezpieczną komunikację danych, tj. Nadawca może opisać dane w sposób zrozumiały dla odbiorcy, ale w przypadku DTD dane mogą zostać źle zrozumiane przez odbiorcę.
• Schematy XML są rozszerzalne, podczas gdy DTD nie jest rozszerzalne.

AKTUALIZACJA : 26.08.2015

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

Z drugiej strony:

• DTD umożliwia zdefiniowanie nowych wartości ENTITY do użycia w pliku XML.
• DTD umożliwia rozszerzenie go lokalnie na pojedynczy plik XML.

Jak wiele osób wspomniało wcześniej, schemat XML wykorzystuje składnię opartą na języku XML, a DTD mają 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, a każdy student ma dwa elementy „nazwa” i „rok”. Zwróć uwagę, że w moim kodzie używa się "// ->" tylko do komentarzy.

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

Definicja schematu 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 poprzedza XML i dlatego sam w sobie nie jest poprawnym XML. To prawdopodobnie największy powód wynalazku XSD.

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 rozwlekły, jego składnia jest rozszerzeniem XML, co ułatwia szybką naukę.

Jedną z różnic jest to, że w DTD model zawartości elementu jest całkowicie określony przez jego nazwę, niezależnie od tego, gdzie pojawia się w dokumencie:

Zakładając, że chcesz

• personelementem
• z elementem potomnym o nazwie name
• namesam ma elementy podrzędne firsti last.

Lubię to

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

Jeśli cityelementem w tym samym dokumencie musi również mieć nazwę „” elementu podrzędnego DTD wymaga, aby ta „nazwa” element musi mieć elementy podrzędne first, a lasttakże. Pomimo tego, że city.namenie wymaga firsti lastjak dzieci.

Natomiast schemat XML umożliwia lokalną deklarację typów elementów potomnych; możesz zadeklarować nameelementy potomne dla obu personi cityosobno. W ten sposób nadając im właściwe modele treści w tych kontekstach.

Inną ważną różnicą jest obsługa przestrzeni nazw. Ponieważ DTD są częścią oryginalnej specyfikacji XML (i są dziedziczone z SGML), w ogóle nie uwzględniają 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 przewrotów, takich jak zmuszanie do definiowania prefiksów w DTD i używanie tylko tych prefiksów, zamiast używania dowolnych prefiksów.

Dla mnie inne różnice są w większości powierzchowne. Obsługę typów danych można łatwo dodać do DTD, a składnia to po prostu składnia. (Na przykład uważam składnię schematu XML za okropną i nigdy nie chciałbym ręcznie utrzymywać schematu XML, czego nie powiedziałbym o DTD lub schematach RELAX NG; jeśli z jakiegoś powodu potrzebuję schematu XML, zwykle piszę RELAX NG i przekonwertuj go trang.)

Podobieństwa :

DTD i Schematy pełnią te same podstawowe funkcje:

• Po pierwsze, oboje deklarują listę pralni 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 utworzenie pliku XML w Twoim przepływie pracy i
• Po trzecie, zarówno DTD, jak i schematy zapewniają metody ograniczania lub wymuszania typu lub formatu 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 w przypadku aplikacji intensywnie korzystających z tekstu, a schematy mają kilka zalet w przypadku przepływów pracy wymagających dużej ilości danych.

• Schematy są napisane w XML i dlatego podlegają tym samym regułom, podczas gdy DTD są napisane w zupełnie innym języku.

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żesz użyć wszystkich pierwotnych typów danych, których używasz w języku programowania, i masz elastyczność definiowania własnych niestandardowych typów danych.

Deweloper budujący schemat może tworzyć niestandardowe typy danych na podstawie podstawowych typów danych oraz przy użyciu różnych operatorów i modyfikatorów.

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. Ponad 15 lat później widzę, że większość XML nie jest przyjazna dla użytkownika i niezbyt rozszerzalna (w zależności od jego zastosowania). Gdy tylko jakieś sprytne chodaki podłączyły XML do bazy danych, wiedziałem, że typy danych są prawie nieuniknione. Powinieneś zobaczyć XSLT (plik transformacji), nad którym pracowałem poprzedniego dnia. Jeśli to nie jest programowanie, nie wiem, co to jest! W dzisiejszych czasach nie jest niczym niezwykłym, że wszelkiego rodzaju problemy związane z danymi XML lub interfejsami uległy awarii. Uwielbiam XML, ale odszedł daleko od swojego pierwotnego altruistycznego punktu wyjścia.

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

XML DTD

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

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

Schemat XML

Schemat XML umożliwia autorom schematu określenie, że dane ilości elementu muszą być liczbami lub, jeszcze dokładniej, liczbą całkowitą. 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>

DTD jest raczej przestarzałe, ponieważ ma ograniczoną użyteczność 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 zrozumienie i utrzymanie.

DTD wskazuje składnię elementu XML

Schematy XML to alternatywa firmy Microsoft dla DTD do sprawdzania poprawności XML