Ho cercato su Google questa domanda, ma non capisco chiaramente cosa sia uno schema XML e DTD (definizione del tipo di documento) e perché lo schema XML sia più potente rispetto a DTD.

Qualsiasi consiglio sarebbe molto apprezzato.

Dalla sezione Differenze tra DTD e schema dell'articolo Conversione di un DTD in uno schema :

La differenza fondamentale tra DTD e schema XML è che lo schema XML utilizza una sintassi basata su XML, mentre i DTD hanno una sintassi unica trattenuta dai DTD SGML. Sebbene i DTD siano spesso criticati a causa di questa necessità di apprendere una nuova sintassi, la stessa sintassi è piuttosto concisa. È vero il contrario per XML Schema, che sono prolissi, ma usano anche tag e XML in modo che gli autori di XML trovino la sintassi di XML Schema meno intimidatoria.

L'obiettivo dei DTD era mantenere un livello di compatibilità con SGML per le applicazioni che potrebbero voler convertire i DTD SGML in DTD XML. Tuttavia, in linea con uno degli obiettivi di XML, "la terseness nel markup XML è di minima importanza", non vi è alcuna reale preoccupazione nel mantenere breve la sintassi.

[...]

Quindi quali sono alcune delle altre differenze che potrebbero essere particolarmente importanti quando stiamo convertendo un DTD? Diamo un'occhiata.

Digitando

La differenza più significativa tra DTD e schema XML è la capacità di creare e utilizzare tipi di dati nello schema in combinazione con dichiarazioni di elementi e attributi. In effetti, è una differenza così importante che metà della Raccomandazione dello schema XML è dedicata al datatyping e allo schema XML. Copriamo i tipi di dati in dettaglio nella Parte III di questo libro, "XML Schema Datatypes".

[...]

Vincoli di occorrenza

Un'altra area in cui DTD e Schema differiscono in modo significativo è con i vincoli di occorrenza. Se ricordi dai nostri precedenti esempi nel capitolo 2, "Schema Structure" (o il tuo lavoro con i DTD), ci sono tre simboli che puoi usare per limitare il numero di occorrenze di un elemento: *, + e?.

[...]

enumerazioni

Quindi, supponiamo di avere un elemento e che volessimo essere in grado di definire un attributo size per la camicia, che consentisse agli utenti di scegliere una dimensione: piccola, media o grande. Il nostro DTD sarebbe simile a questo:

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

[...]

E se volessimo sizeessere un elemento? Non possiamo farlo con un DTD. I DTD non forniscono enumerazioni nel contenuto testuale di un elemento. Tuttavia, a causa dei tipi di dati con Schema, quando abbiamo dichiarato l'enumerazione nell'esempio precedente, abbiamo effettivamente creato un simpleTypechiamato size_valuesche ora possiamo usare con un elemento:

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

[...]

Le differenze tra una definizione di schema XML (XSD) e una definizione del tipo di documento (DTD) includono:

• Gli schemi XML sono scritti in XML mentre DTD sono derivati ​​dalla sintassi SGML.
• Gli schemi XML definiscono tipi di dati per elementi e attributi mentre DTD non supporta tipi di dati.
• Gli schemi XML consentono il supporto per gli spazi dei nomi mentre DTD no.
• Gli schemi XML definiscono il numero e l'ordine degli elementi figlio, mentre DTD no.
• Gli schemi XML possono essere manipolati da soli con XML DOM ma non è possibile in caso di DTD.
• utilizzando lo schema XML l'utente non deve imparare una nuova lingua ma lavorare con DTD è difficile per un utente.
• Lo schema XML fornisce una comunicazione sicura dei dati, vale a dire che il mittente può descrivere i dati in modo comprensibile al destinatario, ma in caso di dati DTD possono essere fraintesi dal destinatario.
• Gli schemi XML sono estensibili mentre DTD non è estensibile.

AGGIORNAMENTO : 2015.08.26

Non tutti questi punti elenco sono precisi al 100%, ma ottieni l'essenza.

D'altro canto:

• DTD consente di definire nuovi valori ENTITY da utilizzare nel file XML.
• DTD ti consente di estenderlo locale a un singolo file XML.

Come molte persone hanno già detto in precedenza, lo schema XML utilizza una sintassi basata su XML e i DTD hanno una sintassi unica. DTD non supporta i tipi di dati, il che conta.

Vediamo un esempio molto semplice in cui l'università ha più studenti e ogni studente ha due elementi "nome" e "anno". Nota che ho usato "// ->" nel mio codice solo per commenti.

Ora scriverò questo esempio sia in DTD che in 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>

DTD è precedente a XML e pertanto non è XML stesso. Questo è probabilmente il motivo principale dell'invenzione di XSD.

Somiglianze tra XSD e DTD

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

Differenze tra XSD e DTD

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

Inoltre, sebbene XSD sia poco dettagliato, la sua sintassi è l'estensione di XML, il che rende conveniente l'apprendimento veloce.

Una differenza è che in un DTD il modello di contenuto di un elemento è completamente determinato dal suo nome, indipendentemente da dove appare nel documento:

Supponendo che tu voglia avere

• un personelemento
• con un elemento figlio chiamato name
• uno namestesso ha elementi figlio firste last.

Come questo

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

Se un cityelemento nello stesso documento ha anche bisogno di avere 'nome' un elemento figlio DTD richiede che questo elemento di 'nome' deve avere elementi figlio firste lastpure. Nonostante il fatto che city.namenon richiede firste lastcome bambini.

Al contrario, lo schema XML consente di dichiarare localmente i tipi di elementi figlio; potresti dichiarare gli nameelementi figlio per entrambi persone cityseparatamente. Dando così loro i propri modelli di contenuto in quei contesti.

L'altra grande differenza è il supporto per gli spazi dei nomi. Poiché i DTD fanno parte della specifica XML originale (ed ereditati da SGML), non sono affatto consapevoli dello spazio dei nomi perché gli spazi dei nomi XML sono stati specificati in seguito. È possibile utilizzare i DTD in combinazione con gli spazi dei nomi, ma richiede alcune contorsioni, come essere costretti a definire i prefissi nel DTD e usare solo quei prefissi, invece di poter usare prefissi arbitrari.

Per me, altre differenze sono per lo più superficiali. Il supporto del tipo di dati potrebbe essere facilmente aggiunto ai DTD e la sintassi è solo sintassi. (Per uno, trovo la sintassi dello schema XML orribile e non vorrei mai mantenere uno schema XML, che non direi sui DTD o sugli schemi RELAX NG; se per qualche motivo ho bisogno di uno schema XML, di solito scrivo un RELAX NG e convertirlo con trang.)

Somiglianze :

DTD e schemi svolgono entrambi le stesse funzioni di base:

• Innanzitutto, entrambi dichiarano un elenco di elementi e attributi.
• In secondo luogo, entrambi descrivono il modo in cui tali elementi sono raggruppati, nidificati o utilizzati all'interno dell'XML. In altre parole, dichiarano le regole in base alle quali stai permettendo a qualcuno di creare un file XML nel tuo flusso di lavoro, e
• In terzo luogo, sia i DTD che gli schemi forniscono metodi per limitare o forzare il tipo o il formato di un elemento. Ad esempio, all'interno del DTD o dello schema è possibile forzare la scrittura di un campo data come 01/05/06 o 1/5/2006.

differenze:

• I DTD sono migliori per le applicazioni ad alta intensità di testo, mentre gli schemi presentano numerosi vantaggi per i flussi di lavoro ad alta intensità di dati.

• Gli schemi sono scritti in XML e quindi seguono le stesse regole, mentre i DTD sono scritti in un linguaggio completamente diverso.

Esempi:

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 può avere solo due tipi di dati, il CDATA e il PCDATA. Ma in uno schema puoi usare tutti i tipi di dati primitivi che usi nel linguaggio di programmazione e hai la flessibilità di definire i tuoi tipi di dati personalizzati.

Lo sviluppatore che crea uno schema può creare tipi di dati personalizzati in base ai tipi di dati principali e utilizzando diversi operatori e modificatori.

Quando è uscito XML per la prima volta, ci è stato detto che avrebbe risolto tutti i nostri problemi: XML sarà facile da usare, estendibile all'infinito, eviterà di scrivere in modo forte e non richiederà alcuna abilità di programmazione. Ho appreso dei DTD e ho scritto il mio parser XML. Più di 15 anni dopo, vedo che la maggior parte degli XML non è facile da usare e non molto estensibile (a seconda del suo utilizzo). Non appena alcuni zoccoli intelligenti hanno collegato XML a un database, ho capito che i tipi di dati erano quasi inevitabili. E dovresti vedere l'XSLT (file di trasformazione) che ho dovuto lavorare l'altro giorno. Se questa non è programmazione, non so cosa sia! Al giorno d'oggi non è insolito vedere tutti i tipi di problemi relativi ai dati XML o alle interfacce andare male. Adoro XML, ma si è allontanato dal suo originale punto di partenza altruistico.

La risposta breve? I DTD sono stati deprecati a favore degli XSD perché un XSD consente di definire una struttura XML con maggiore precisione.

DTD XML

Lo scopo di un DTD è definire la struttura di un documento XML. Definisce la struttura con un elenco di elementi legali:

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

Schema XML

Lo schema XML consente agli autori dello schema di specificare che i dati della quantità di elementi devono essere numerici o, ancora più specificamente, un numero intero. Nel seguente esempio ho usato 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 è praticamente obsoleto perché è limitato nella sua utilità come linguaggio di schema, non supporta lo spazio dei nomi e non supporta il tipo di dati. Inoltre, la sintassi di DTD è piuttosto complicata, rendendo difficile la comprensione e la manutenzione.

DTD indica la sintassi dell'elemento XML

Gli schemi XML sono l'alternativa di Microsoft a DTD per la convalida di XML